libereco
Version:
Liberate your photos from the hosting platforms lockin.
1,487 lines (1,307 loc) • 101 kB
JavaScript
/*!
* =============================================================
* Ender: open module JavaScript framework (https://ender.no.de)
* Build: ender build valentine jeesh --output static/a/ender
* =============================================================
*/
/*!
* Ender: open module JavaScript framework (client-lib)
* copyright Dustin Diaz & Jacob Thornton 2011-2012 (@ded @fat)
* http://ender.no.de
* License MIT
*/
(function (context) {
// a global object for node.js module compatiblity
// ============================================
context['global'] = context
// Implements simple module system
// losely based on CommonJS Modules spec v1.1.1
// ============================================
var modules = {}
, old = context['$']
, oldEnder = context['ender']
, oldRequire = context['require']
, oldProvide = context['provide']
function require (identifier) {
// modules can be required from ender's build system, or found on the window
var module = modules['$' + identifier] || window[identifier]
if (!module) throw new Error("Ender Error: Requested module '" + identifier + "' has not been defined.")
return module
}
function provide (name, what) {
return (modules['$' + name] = what)
}
context['provide'] = provide
context['require'] = require
function aug(o, o2) {
for (var k in o2) k != 'noConflict' && k != '_VERSION' && (o[k] = o2[k])
return o
}
/**
* main Ender return object
* @constructor
* @param {Array|Node|string} s a CSS selector or DOM node(s)
* @param {Array.|Node} r a root node(s)
*/
function Ender(s, r) {
var elements
, i
this.selector = s
// string || node || nodelist || window
if (typeof s == 'undefined') {
elements = []
this.selector = ''
} else if (typeof s == 'string' || s.nodeName || (s.length && 'item' in s) || s == window) {
elements = ender._select(s, r)
} else {
elements = isFinite(s.length) ? s : [s]
}
this.length = elements.length
for (i = this.length; i--;) this[i] = elements[i]
}
/**
* @param {function(el, i, inst)} fn
* @param {Object} opt_scope
* @returns {Ender}
*/
Ender.prototype['forEach'] = function (fn, opt_scope) {
var i, l
// opt out of native forEach so we can intentionally call our own scope
// defaulting to the current item and be able to return self
for (i = 0, l = this.length; i < l; ++i) i in this && fn.call(opt_scope || this[i], this[i], i, this)
// return self for chaining
return this
}
Ender.prototype.$ = ender // handy reference to self
function ender(s, r) {
return new Ender(s, r)
}
ender['_VERSION'] = '0.4.3-dev'
ender.fn = Ender.prototype // for easy compat to jQuery plugins
ender.ender = function (o, chain) {
aug(chain ? Ender.prototype : ender, o)
}
ender._select = function (s, r) {
if (typeof s == 'string') return (r || document).querySelectorAll(s)
if (s.nodeName) return [s]
return s
}
// use callback to receive Ender's require & provide and remove them from global
ender.noConflict = function (callback) {
context['$'] = old
if (callback) {
context['provide'] = oldProvide
context['require'] = oldRequire
context['ender'] = oldEnder
if (typeof callback == 'function') callback(require, provide, this)
}
return this
}
if (typeof module !== 'undefined' && module.exports) module.exports = ender
// use subscript notation as extern for Closure compilation
context['ender'] = context['$'] = ender
}(this));
!function () {
var module = { exports: {} }, exports = module.exports;
/*!
* Valentine: JavaScript's functional Sister
* (c) Dustin Diaz 2012
* https://github.com/ded/valentine
* License MIT
*/
(function (name, definition) {
if (typeof module != 'undefined') module.exports = definition()
else if (typeof define == 'function') define(definition)
else this[name] = this['v'] = definition()
})('valentine', function () {
var context = this
, old = context.v
, ap = []
, hasOwn = Object.prototype.hasOwnProperty
, n = null
, slice = ap.slice
, nativ = 'map' in ap
, nativ18 = 'reduce' in ap
, trimReplace = /(^\s*|\s*$)/g
, iters = {
each: nativ ?
function (a, fn, scope) {
ap.forEach.call(a, fn, scope)
} :
function (a, fn, scope) {
for (var i = 0, l = a.length; i < l; i++) {
i in a && fn.call(scope, a[i], i, a)
}
}
, map: nativ ?
function (a, fn, scope) {
return ap.map.call(a, fn, scope)
} :
function (a, fn, scope) {
var r = [], i
for (i = 0, l = a.length; i < l; i++) {
i in a && (r[i] = fn.call(scope, a[i], i, a))
}
return r
}
, some: nativ ?
function (a, fn, scope) {
return a.some(fn, scope)
} :
function (a, fn, scope) {
for (var i = 0, l = a.length; i < l; i++) {
if (i in a && fn.call(scope, a[i], i, a)) return true
}
return false
}
, every: nativ ?
function (a, fn, scope) {
return a.every(fn, scope)
} :
function (a, fn, scope) {
for (var i = 0, l = a.length; i < l; i++) {
if (i in a && !fn.call(scope, a[i], i, a)) return false
}
return true
}
, filter: nativ ?
function (a, fn, scope) {
return a.filter(fn, scope)
} :
function (a, fn, scope) {
for (var r = [], i = 0, j = 0, l = a.length; i < l; i++) {
if (i in a) {
if (!fn.call(scope, a[i], i, a)) continue;
r[j++] = a[i]
}
}
return r
}
, indexOf: nativ ?
function (a, el, start) {
return a.indexOf(el, isFinite(start) ? start : 0)
} :
function (a, el, start) {
start = start || 0
start = start < 0 ? 0 : start
start = start > a.length ? a.length : start
for (var i = start; i < a.length; i++) {
if (i in a && a[i] === el) return i
}
return -1
}
, lastIndexOf: nativ ?
function (a, el, start) {
return a.lastIndexOf(el, isFinite(start) ? start : a.length)
} :
function (a, el, start) {
start = start || a.length
start = start >= a.length ? a.length :
start < 0 ? a.length + start : start
for (var i = start; i >= 0; --i) {
if (i in a && a[i] === el) {
return i
}
}
return -1
}
, reduce: nativ18 ?
function (o, i, m, c) {
return ap.reduce.call(o, i, m, c);
} :
function (obj, iterator, memo, context) {
if (!obj) obj = []
var i = 0, l = obj.length
if (arguments.length < 3) {
do {
if (i in obj) {
memo = obj[i++]
break;
}
if (++i >= l) {
throw new TypeError('Empty array')
}
} while (1)
}
for (; i < l; i++) {
if (i in obj) {
memo = iterator.call(context, memo, obj[i], i, obj)
}
}
return memo
}
, reduceRight: nativ18 ?
function (o, i, m, c) {
return ap.reduceRight.call(o, i, m, c)
} :
function (obj, iterator, memo, context) {
!obj && (obj = [])
var l = obj.length, i = l - 1
if (arguments.length < 3) {
do {
if (i in obj) {
memo = obj[i--]
break;
}
if (--i < 0) {
throw new TypeError('Empty array')
}
} while (1)
}
for (; i >= 0; i--) {
if (i in obj) {
memo = iterator.call(context, memo, obj[i], i, obj)
}
}
return memo
}
, find: function (obj, iterator, context) {
var result
iters.some(obj, function (value, index, list) {
if (iterator.call(context, value, index, list)) {
result = value
return true
}
})
return result
}
, reject: function (a, fn, scope) {
var r = []
for (var i = 0, j = 0, l = a.length; i < l; i++) {
if (i in a) {
if (fn.call(scope, a[i], i, a)) {
continue;
}
r[j++] = a[i]
}
}
return r
}
, size: function (a) {
return o.toArray(a).length
}
, compact: function (a) {
return iters.filter(a, function (value) {
return !!value
})
}
, flatten: function (a) {
return iters.reduce(a, function (memo, value) {
if (is.arr(value)) {
return memo.concat(iters.flatten(value))
}
memo[memo.length] = value
return memo
}, [])
}
, uniq: function (ar, opt_iterator) {
var a = [], i, j
ar = opt_iterator ? iters.map(ar, opt_iterator) : ar
label:
for (i = 0; i < ar.length; i++) {
for (j = 0; j < a.length; j++) {
if (a[j] === ar[i]) {
continue label
}
}
a[a.length] = ar[i]
}
return a
}
, merge: function (one, two) {
var i = one.length, j = 0, l
if (isFinite(two.length)) {
for (l = two.length; j < l; j++) {
one[i++] = two[j]
}
} else {
while (two[j] !== undefined) {
first[i++] = second[j++]
}
}
one.length = i
return one
}
, inArray: function (ar, needle) {
return !!~iters.indexOf(ar, needle)
}
}
var is = {
fun: function (f) {
return typeof f === 'function'
}
, str: function (s) {
return typeof s === 'string'
}
, ele: function (el) {
return !!(el && el.nodeType && el.nodeType == 1)
}
, arr: function (ar) {
return ar instanceof Array
}
, arrLike: function (ar) {
return (ar && ar.length && isFinite(ar.length))
}
, num: function (n) {
return typeof n === 'number'
}
, bool: function (b) {
return (b === true) || (b === false)
}
, args: function (a) {
return !!(a && hasOwn.call(a, 'callee'))
}
, emp: function (o) {
var i = 0
return is.arr(o) ? o.length === 0 :
is.obj(o) ? (function () {
for (var k in o) {
i++
break;
}
return (i === 0)
}()) :
o === ''
}
, dat: function (d) {
return !!(d && d.getTimezoneOffset && d.setUTCFullYear)
}
, reg: function (r) {
return !!(r && r.test && r.exec && (r.ignoreCase || r.ignoreCase === false))
}
, nan: function (n) {
return n !== n
}
, nil: function (o) {
return o === n
}
, und: function (o) {
return typeof o === 'undefined'
}
, def: function (o) {
return typeof o !== 'undefined'
}
, obj: function (o) {
return o instanceof Object && !is.fun(o) && !is.arr(o)
}
}
var o = {
each: function (a, fn, scope) {
is.arrLike(a) ?
iters.each(a, fn, scope) : (function () {
for (var k in a) {
hasOwn.call(a, k) && fn.call(scope, k, a[k], a)
}
}())
}
, map: function (a, fn, scope) {
var r = [], i = 0
return is.arrLike(a) ?
iters.map(a, fn, scope) : !function () {
for (var k in a) {
hasOwn.call(a, k) && (r[i++] = fn.call(scope, k, a[k], a))
}
}() && r
}
, pluck: function (a, k) {
return is.arrLike(a) ?
iters.map(a, function (el) {
return el[k]
}) :
o.map(a, function (_, v) {
return v[k]
})
}
, toArray: function (a) {
if (!a) return []
if (is.arr(a)) return a
if (a.toArray) return a.toArray()
if (is.args(a)) return slice.call(a)
return iters.map(a, function (k) {
return k
})
}
, first: function (a) {
return a[0]
}
, last: function (a) {
return a[a.length - 1]
}
, keys: Object.keys ?
function (o) {
return Object.keys(o)
} :
function (obj) {
var keys = [], key
for (key in obj) if (hasOwn.call(obj, key)) keys[keys.length] = key
return keys
}
, values: function (ob) {
return o.map(ob, function (k, v) {
return v
})
}
, extend: function () {
// based on jQuery deep merge
var options, name, src, copy, clone
, target = arguments[0], i = 1, length = arguments.length
for (; i < length; i++) {
if ((options = arguments[i]) !== n) {
// Extend the base object
for (name in options) {
src = target[name]
copy = options[name]
if (target === copy) {
continue;
}
if (copy && (is.obj(copy))) {
clone = src && is.obj(src) ? src : {}
target[name] = o.extend(clone, copy);
} else if (copy !== undefined) {
target[name] = copy
}
}
}
}
return target
}
, trim: String.prototype.trim ?
function (s) {
return s.trim()
} :
function (s) {
return s.replace(trimReplace, '')
}
, bind: function (scope, fn) {
var args = arguments.length > 2 ? slice.call(arguments, 2) : null
return function () {
return fn.apply(scope, args ? args.concat(slice.call(arguments)) : arguments)
}
}
, curry: function (fn) {
if (arguments.length == 1) return fn
var args = slice.call(arguments, 1)
return function () {
return fn.apply(null, args.concat(slice.call(arguments)))
}
}
, parallel: function (fns, callback) {
var args = o.toArray(arguments)
, len = 0
, returns = []
, flattened = []
if (is.arr(fns) && fns.length === 0 || (is.fun(fns) && args.length === 1)) throw new TypeError('Empty parallel array')
if (!is.arr(fns)) {
callback = args.pop()
fns = args
}
iters.each(fns, function (el, i) {
el(function () {
var a = o.toArray(arguments)
, e = a.shift()
if (e) return callback(e)
returns[i] = a
if (fns.length == ++len) {
returns.unshift(n)
iters.each(returns, function (r) {
flattened = flattened.concat(r)
})
callback.apply(n, flattened)
}
})
})
}
, waterfall: function (fns, callback) {
var args = o.toArray(arguments)
, index = 0
if (is.arr(fns) && fns.length === 0 || (is.fun(fns) && args.length === 1)) throw new TypeError('Empty waterfall array')
if (!is.arr(fns)) {
callback = args.pop()
fns = args
}
(function f() {
var args = o.toArray(arguments)
args.push(f)
var err = args.shift()
if (!err && fns.length) fns.shift().apply(n, args)
else {
args.pop()
args.unshift(err)
callback.apply(n, args)
}
}(n))
}
, queue: function (ar) {
return new Queue(is.arrLike(ar) ? ar : o.toArray(arguments))
}
}
function Queue (a) {
this.values = a
this.index = 0
}
Queue.prototype.next = function () {
this.index < this.values.length && this.values[this.index++]()
return this
}
function v(a, scope) {
return new Valentine(a, scope)
}
function aug(o, o2) {
for (var k in o2) o[k] = o2[k]
}
aug(v, iters)
aug(v, o)
v.is = is
v.v = v // vainglory
// peoples like the object style
function Valentine(a, scope) {
this.val = a
this._scope = scope || n
this._chained = 0
}
v.each(v.extend({}, iters, o), function (name, fn) {
Valentine.prototype[name] = function () {
var a = v.toArray(arguments)
a.unshift(this.val)
var ret = fn.apply(this._scope, a)
this.val = ret
return this._chained ? this : ret
}
})
// people like chaining
aug(Valentine.prototype, {
chain: function () {
this._chained = 1
return this
}
, value: function () {
return this.val
}
})
v.noConflict = function () {
context.v = old
return this
}
return v
});
provide("valentine", module.exports);
var v = require('valentine')
ender.ender(v)
ender.ender({
merge: v.merge
, extend: v.extend
, each: v.each
, map: v.map
, toArray: v.toArray
, keys: v.keys
, values: v.values
, trim: v.trim
, bind: v.bind
, curry: v.curry
, parallel: v.parallel
, waterfall: v.waterfall
, inArray: v.inArray
, queue: v.queue
})
}();
!function () {
var module = { exports: {} }, exports = module.exports;
/*!
* bean.js - copyright Jacob Thornton 2011
* https://github.com/fat/bean
* MIT License
* special thanks to:
* dean edwards: http://dean.edwards.name/
* dperini: https://github.com/dperini/nwevents
* the entire mootools team: github.com/mootools/mootools-core
*/
!function (name, context, definition) {
if (typeof module !== 'undefined') module.exports = definition(name, context);
else if (typeof define === 'function' && typeof define.amd === 'object') define(definition);
else context[name] = definition(name, context);
}('bean', this, function (name, context) {
var win = window
, old = context[name]
, overOut = /over|out/
, namespaceRegex = /[^\.]*(?=\..*)\.|.*/
, nameRegex = /\..*/
, addEvent = 'addEventListener'
, attachEvent = 'attachEvent'
, removeEvent = 'removeEventListener'
, detachEvent = 'detachEvent'
, ownerDocument = 'ownerDocument'
, targetS = 'target'
, qSA = 'querySelectorAll'
, doc = document || {}
, root = doc.documentElement || {}
, W3C_MODEL = root[addEvent]
, eventSupport = W3C_MODEL ? addEvent : attachEvent
, slice = Array.prototype.slice
, mouseTypeRegex = /click|mouse(?!(.*wheel|scroll))|menu|drag|drop/i
, mouseWheelTypeRegex = /mouse.*(wheel|scroll)/i
, textTypeRegex = /^text/i
, touchTypeRegex = /^touch|^gesture/i
, ONE = {} // singleton for quick matching making add() do one()
, nativeEvents = (function (hash, events, i) {
for (i = 0; i < events.length; i++)
hash[events[i]] = 1
return hash
}({}, (
'click dblclick mouseup mousedown contextmenu ' + // mouse buttons
'mousewheel mousemultiwheel DOMMouseScroll ' + // mouse wheel
'mouseover mouseout mousemove selectstart selectend ' + // mouse movement
'keydown keypress keyup ' + // keyboard
'orientationchange ' + // mobile
'focus blur change reset select submit ' + // form elements
'load unload beforeunload resize move DOMContentLoaded '+ // window
'readystatechange message ' + // window
'error abort scroll ' + // misc
(W3C_MODEL ? // element.fireEvent('onXYZ'... is not forgiving if we try to fire an event
// that doesn't actually exist, so make sure we only do these on newer browsers
'show ' + // mouse buttons
'input invalid ' + // form elements
'touchstart touchmove touchend touchcancel ' + // touch
'gesturestart gesturechange gestureend ' + // gesture
'readystatechange pageshow pagehide popstate ' + // window
'hashchange offline online ' + // window
'afterprint beforeprint ' + // printing
'dragstart dragenter dragover dragleave drag drop dragend ' + // dnd
'loadstart progress suspend emptied stalled loadmetadata ' + // media
'loadeddata canplay canplaythrough playing waiting seeking ' + // media
'seeked ended durationchange timeupdate play pause ratechange ' + // media
'volumechange cuechange ' + // media
'checking noupdate downloading cached updateready obsolete ' + // appcache
'' : '')
).split(' ')
))
, customEvents = (function () {
var cdp = 'compareDocumentPosition'
, isAncestor = cdp in root
? function (element, container) {
return container[cdp] && (container[cdp](element) & 16) === 16
}
: 'contains' in root
? function (element, container) {
container = container.nodeType === 9 || container === window ? root : container
return container !== element && container.contains(element)
}
: function (element, container) {
while (element = element.parentNode) if (element === container) return 1
return 0
}
function check(event) {
var related = event.relatedTarget
return !related
? related === null
: (related !== this && related.prefix !== 'xul' && !/document/.test(this.toString()) && !isAncestor(related, this))
}
return {
mouseenter: { base: 'mouseover', condition: check }
, mouseleave: { base: 'mouseout', condition: check }
, mousewheel: { base: /Firefox/.test(navigator.userAgent) ? 'DOMMouseScroll' : 'mousewheel' }
}
}())
, fixEvent = (function () {
var commonProps = 'altKey attrChange attrName bubbles cancelable ctrlKey currentTarget detail eventPhase getModifierState isTrusted metaKey relatedNode relatedTarget shiftKey srcElement target timeStamp type view which'.split(' ')
, mouseProps = commonProps.concat('button buttons clientX clientY dataTransfer fromElement offsetX offsetY pageX pageY screenX screenY toElement'.split(' '))
, mouseWheelProps = mouseProps.concat('wheelDelta wheelDeltaX wheelDeltaY wheelDeltaZ axis'.split(' ')) // 'axis' is FF specific
, keyProps = commonProps.concat('char charCode key keyCode keyIdentifier keyLocation'.split(' '))
, textProps = commonProps.concat(['data'])
, touchProps = commonProps.concat('touches targetTouches changedTouches scale rotation'.split(' '))
, messageProps = commonProps.concat(['data', 'origin', 'source'])
, preventDefault = 'preventDefault'
, createPreventDefault = function (event) {
return function () {
if (event[preventDefault])
event[preventDefault]()
else
event.returnValue = false
}
}
, stopPropagation = 'stopPropagation'
, createStopPropagation = function (event) {
return function () {
if (event[stopPropagation])
event[stopPropagation]()
else
event.cancelBubble = true
}
}
, createStop = function (synEvent) {
return function () {
synEvent[preventDefault]()
synEvent[stopPropagation]()
synEvent.stopped = true
}
}
, copyProps = function (event, result, props) {
var i, p
for (i = props.length; i--;) {
p = props[i]
if (!(p in result) && p in event) result[p] = event[p]
}
}
return function (event, isNative) {
var result = { originalEvent: event, isNative: isNative }
if (!event)
return result
var props
, type = event.type
, target = event[targetS] || event.srcElement
result[preventDefault] = createPreventDefault(event)
result[stopPropagation] = createStopPropagation(event)
result.stop = createStop(result)
result[targetS] = target && target.nodeType === 3 ? target.parentNode : target
if (isNative) { // we only need basic augmentation on custom events, the rest is too expensive
if (type.indexOf('key') !== -1) {
props = keyProps
result.keyCode = event.keyCode || event.which
} else if (mouseTypeRegex.test(type)) {
props = mouseProps
result.rightClick = event.which === 3 || event.button === 2
result.pos = { x: 0, y: 0 }
if (event.pageX || event.pageY) {
result.clientX = event.pageX
result.clientY = event.pageY
} else if (event.clientX || event.clientY) {
result.clientX = event.clientX + doc.body.scrollLeft + root.scrollLeft
result.clientY = event.clientY + doc.body.scrollTop + root.scrollTop
}
if (overOut.test(type))
result.relatedTarget = event.relatedTarget || event[(type === 'mouseover' ? 'from' : 'to') + 'Element']
} else if (touchTypeRegex.test(type)) {
props = touchProps
} else if (mouseWheelTypeRegex.test(type)) {
props = mouseWheelProps
} else if (textTypeRegex.test(type)) {
props = textProps
} else if (type === 'message') {
props = messageProps
}
copyProps(event, result, props || commonProps)
}
return result
}
}())
// if we're in old IE we can't do onpropertychange on doc or win so we use doc.documentElement for both
, targetElement = function (element, isNative) {
return !W3C_MODEL && !isNative && (element === doc || element === win) ? root : element
}
// we use one of these per listener, of any type
, RegEntry = (function () {
function entry(element, type, handler, original, namespaces) {
var isNative = this.isNative = nativeEvents[type] && element[eventSupport]
this.element = element
this.type = type
this.handler = handler
this.original = original
this.namespaces = namespaces
this.custom = customEvents[type]
this.eventType = W3C_MODEL || isNative ? type : 'propertychange'
this.customType = !W3C_MODEL && !isNative && type
this[targetS] = targetElement(element, isNative)
this[eventSupport] = this[targetS][eventSupport]
}
entry.prototype = {
// given a list of namespaces, is our entry in any of them?
inNamespaces: function (checkNamespaces) {
var i, j
if (!checkNamespaces)
return true
if (!this.namespaces)
return false
for (i = checkNamespaces.length; i--;) {
for (j = this.namespaces.length; j--;) {
if (checkNamespaces[i] === this.namespaces[j])
return true
}
}
return false
}
// match by element, original fn (opt), handler fn (opt)
, matches: function (checkElement, checkOriginal, checkHandler) {
return this.element === checkElement &&
(!checkOriginal || this.original === checkOriginal) &&
(!checkHandler || this.handler === checkHandler)
}
}
return entry
}())
, registry = (function () {
// our map stores arrays by event type, just because it's better than storing
// everything in a single array. uses '$' as a prefix for the keys for safety
var map = {}
// generic functional search of our registry for matching listeners,
// `fn` returns false to break out of the loop
, forAll = function (element, type, original, handler, fn) {
if (!type || type === '*') {
// search the whole registry
for (var t in map) {
if (t.charAt(0) === '$')
forAll(element, t.substr(1), original, handler, fn)
}
} else {
var i = 0, l, list = map['$' + type], all = element === '*'
if (!list)
return
for (l = list.length; i < l; i++) {
if (all || list[i].matches(element, original, handler))
if (!fn(list[i], list, i, type))
return
}
}
}
, has = function (element, type, original) {
// we're not using forAll here simply because it's a bit slower and this
// needs to be fast
var i, list = map['$' + type]
if (list) {
for (i = list.length; i--;) {
if (list[i].matches(element, original, null))
return true
}
}
return false
}
, get = function (element, type, original) {
var entries = []
forAll(element, type, original, null, function (entry) { return entries.push(entry) })
return entries
}
, put = function (entry) {
(map['$' + entry.type] || (map['$' + entry.type] = [])).push(entry)
return entry
}
, del = function (entry) {
forAll(entry.element, entry.type, null, entry.handler, function (entry, list, i) {
list.splice(i, 1)
if (list.length === 0)
delete map['$' + entry.type]
return false
})
}
// dump all entries, used for onunload
, entries = function () {
var t, entries = []
for (t in map) {
if (t.charAt(0) === '$')
entries = entries.concat(map[t])
}
return entries
}
return { has: has, get: get, put: put, del: del, entries: entries }
}())
, selectorEngine = doc[qSA]
? function (s, r) {
return r[qSA](s)
}
: function () {
throw new Error('Bean: No selector engine installed') // eeek
}
, setSelectorEngine = function (e) {
selectorEngine = e
}
// add and remove listeners to DOM elements
, listener = W3C_MODEL ? function (element, type, fn, add) {
element[add ? addEvent : removeEvent](type, fn, false)
} : function (element, type, fn, add, custom) {
if (custom && add && element['_on' + custom] === null)
element['_on' + custom] = 0
element[add ? attachEvent : detachEvent]('on' + type, fn)
}
, nativeHandler = function (element, fn, args) {
var beanDel = fn.__beanDel
, handler = function (event) {
event = fixEvent(event || ((this[ownerDocument] || this.document || this).parentWindow || win).event, true)
if (beanDel) // delegated event, fix the fix
event.currentTarget = beanDel.ft(event[targetS], element)
return fn.apply(element, [event].concat(args))
}
handler.__beanDel = beanDel
return handler
}
, customHandler = function (element, fn, type, condition, args, isNative) {
var beanDel = fn.__beanDel
, handler = function (event) {
var target = beanDel ? beanDel.ft(event[targetS], element) : this // deleated event
if (condition ? condition.apply(target, arguments) : W3C_MODEL ? true : event && event.propertyName === '_on' + type || !event) {
if (event) {
event = fixEvent(event || ((this[ownerDocument] || this.document || this).parentWindow || win).event, isNative)
event.currentTarget = target
}
fn.apply(element, event && (!args || args.length === 0) ? arguments : slice.call(arguments, event ? 0 : 1).concat(args))
}
}
handler.__beanDel = beanDel
return handler
}
, once = function (rm, element, type, fn, originalFn) {
// wrap the handler in a handler that does a remove as well
return function () {
rm(element, type, originalFn)
fn.apply(this, arguments)
}
}
, removeListener = function (element, orgType, handler, namespaces) {
var i, l, entry
, type = (orgType && orgType.replace(nameRegex, ''))
, handlers = registry.get(element, type, handler)
for (i = 0, l = handlers.length; i < l; i++) {
if (handlers[i].inNamespaces(namespaces)) {
if ((entry = handlers[i])[eventSupport])
listener(entry[targetS], entry.eventType, entry.handler, false, entry.type)
// TODO: this is problematic, we have a registry.get() and registry.del() that
// both do registry searches so we waste cycles doing this. Needs to be rolled into
// a single registry.forAll(fn) that removes while finding, but the catch is that
// we'll be splicing the arrays that we're iterating over. Needs extra tests to
// make sure we don't screw it up. @rvagg
registry.del(entry)
}
}
}
, addListener = function (element, orgType, fn, originalFn, args) {
var entry
, type = orgType.replace(nameRegex, '')
, namespaces = orgType.replace(namespaceRegex, '').split('.')
if (registry.has(element, type, fn))
return element // no dupe
if (type === 'unload')
fn = once(removeListener, element, type, fn, originalFn) // self clean-up
if (customEvents[type]) {
if (customEvents[type].condition)
fn = customHandler(element, fn, type, customEvents[type].condition, args, true)
type = customEvents[type].base || type
}
entry = registry.put(new RegEntry(element, type, fn, originalFn, namespaces[0] && namespaces))
entry.handler = entry.isNative ?
nativeHandler(element, entry.handler, args) :
customHandler(element, entry.handler, type, false, args, false)
if (entry[eventSupport])
listener(entry[targetS], entry.eventType, entry.handler, true, entry.customType)
}
, del = function (selector, fn, $) {
//TODO: findTarget (therefore $) is called twice, once for match and once for
// setting e.currentTarget, fix this so it's only needed once
var findTarget = function (target, root) {
var i, array = typeof selector === 'string' ? $(selector, root) : selector
for (; target && target !== root; target = target.parentNode) {
for (i = array.length; i--;) {
if (array[i] === target)
return target
}
}
}
, handler = function (e) {
var match = findTarget(e[targetS], this)
match && fn.apply(match, arguments)
}
handler.__beanDel = {
ft: findTarget // attach it here for customEvents to use too
, selector: selector
, $: $
}
return handler
}
, remove = function (element, typeSpec, fn) {
var k, type, namespaces, i
, rm = removeListener
, isString = typeSpec && typeof typeSpec === 'string'
if (isString && typeSpec.indexOf(' ') > 0) {
// remove(el, 't1 t2 t3', fn) or remove(el, 't1 t2 t3')
typeSpec = typeSpec.split(' ')
for (i = typeSpec.length; i--;)
remove(element, typeSpec[i], fn)
return element
}
type = isString && typeSpec.replace(nameRegex, '')
if (type && customEvents[type])
type = customEvents[type].type
if (!typeSpec || isString) {
// remove(el) or remove(el, t1.ns) or remove(el, .ns) or remove(el, .ns1.ns2.ns3)
if (namespaces = isString && typeSpec.replace(namespaceRegex, ''))
namespaces = namespaces.split('.')
rm(element, type, fn, namespaces)
} else if (typeof typeSpec === 'function') {
// remove(el, fn)
rm(element, null, typeSpec)
} else {
// remove(el, { t1: fn1, t2, fn2 })
for (k in typeSpec) {
if (typeSpec.hasOwnProperty(k))
remove(element, k, typeSpec[k])
}
}
return element
}
// 5th argument, $=selector engine, is deprecated and will be removed
, add = function (element, events, fn, delfn, $) {
var type, types, i, args
, originalFn = fn
, isDel = fn && typeof fn === 'string'
if (events && !fn && typeof events === 'object') {
for (type in events) {
if (events.hasOwnProperty(type))
add.apply(this, [ element, type, events[type] ])
}
} else {
args = arguments.length > 3 ? slice.call(arguments, 3) : []
types = (isDel ? fn : events).split(' ')
isDel && (fn = del(events, (originalFn = delfn), $ || selectorEngine)) && (args = slice.call(args, 1))
// special case for one()
this === ONE && (fn = once(remove, element, events, fn, originalFn))
for (i = types.length; i--;) addListener(element, types[i], fn, originalFn, args)
}
return element
}
, one = function () {
return add.apply(ONE, arguments)
}
, fireListener = W3C_MODEL ? function (isNative, type, element) {
var evt = doc.createEvent(isNative ? 'HTMLEvents' : 'UIEvents')
evt[isNative ? 'initEvent' : 'initUIEvent'](type, true, true, win, 1)
element.dispatchEvent(evt)
} : function (isNative, type, element) {
element = targetElement(element, isNative)
// if not-native then we're using onpropertychange so we just increment a custom property
isNative ? element.fireEvent('on' + type, doc.createEventObject()) : element['_on' + type]++
}
, fire = function (element, type, args) {
var i, j, l, names, handlers
, types = type.split(' ')
for (i = types.length; i--;) {
type = types[i].replace(nameRegex, '')
if (names = types[i].replace(namespaceRegex, ''))
names = names.split('.')
if (!names && !args && element[eventSupport]) {
fireListener(nativeEvents[type], type, element)
} else {
// non-native event, either because of a namespace, arguments or a non DOM element
// iterate over all listeners and manually 'fire'
handlers = registry.get(element, type)
args = [false].concat(args)
for (j = 0, l = handlers.length; j < l; j++) {
if (handlers[j].inNamespaces(names))
handlers[j].handler.apply(element, args)
}
}
}
return element
}
, clone = function (element, from, type) {
var i = 0
, handlers = registry.get(from, type)
, l = handlers.length
, args, beanDel
for (;i < l; i++) {
if (handlers[i].original) {
beanDel = handlers[i].handler.__beanDel
if (beanDel) {
args = [ element, beanDel.selector, handlers[i].type, handlers[i].original, beanDel.$]
} else
args = [ element, handlers[i].type, handlers[i].original ]
add.apply(null, args)
}
}
return element
}
, bean = {
add: add
, one: one
, remove: remove
, clone: clone
, fire: fire
, setSelectorEngine: setSelectorEngine
, noConflict: function () {
context[name] = old
return this
}
}
if (win[attachEvent]) {
// for IE, clean up on unload to avoid leaks
var cleanup = function () {
var i, entries = registry.entries()
for (i in entries) {
if (entries[i].type && entries[i].type !== 'unload')
remove(entries[i].element, entries[i].type)
}
win[detachEvent]('onunload', cleanup)
win.CollectGarbage && win.CollectGarbage()
}
win[attachEvent]('onunload', cleanup)
}
return bean
})
provide("bean", module.exports);
!function ($) {
var b = require('bean')
, integrate = function (method, type, method2) {
var _args = type ? [type] : []
return function () {
for (var i = 0, l = this.length; i < l; i++) {
if (!arguments.length && method == 'add' && type) method = 'fire'
b[method].apply(this, [this[i]].concat(_args, Array.prototype.slice.call(arguments, 0)))
}
return this
}
}
, add = integrate('add')
, remove = integrate('remove')
, fire = integrate('fire')
, methods = {
on: add // NOTE: .on() is likely to change in the near future, don't rely on this as-is see https://github.com/fat/bean/issues/55
, addListener: add
, bind: add
, listen: add
, delegate: add
, one: integrate('one')
, off: remove
, unbind: remove
, unlisten: remove
, removeListener: remove
, undelegate: remove
, emit: fire
, trigger: fire
, cloneEvents: integrate('clone')
, hover: function (enter, leave, i) { // i for internal
for (i = this.length; i--;) {
b.add.call(this, this[i], 'mouseenter', enter)
b.add.call(this, this[i], 'mouseleave', leave)
}
return this
}
}
, shortcuts =
('blur change click dblclick error focus focusin focusout keydown keypress '
+ 'keyup load mousedown mouseenter mouseleave mouseout mouseover mouseup '
+ 'mousemove resize scroll select submit unload').split(' ')
for (var i = shortcuts.length; i--;) {
methods[shortcuts[i]] = integrate('add', shortcuts[i])
}
b.setSelectorEngine($)
$.ender(methods, true)
}(ender)
}();
!function () {
var module = { exports: {} }, exports = module.exports;
/*!
* Bonzo: DOM Utility (c) Dustin Diaz 2012
* https://github.com/ded/bonzo
* License MIT
*/
(function (name, definition, context) {
if (typeof module != 'undefined' && module.exports) module.exports = definition()
else if (typeof context['define'] == 'function' && context['define']['amd']) define(name, definition)
else context[name] = definition()
})('bonzo', function() {
var win = window
, doc = win.document
, html = doc.documentElement
, parentNode = 'parentNode'
, query = null // used for setting a selector engine host
, specialAttributes = /^(checked|value|selected|disabled)$/i
, specialTags = /^(select|fieldset|table|tbody|tfoot|td|tr|colgroup)$/i // tags that we have trouble inserting *into*
, table = ['<table>', '</table>', 1]
, td = ['<table><tbody><tr>', '</tr></tbody></table>', 3]
, option = ['<select>', '</select>', 1]
, noscope = ['_', '', 0, 1]
, tagMap = { // tags that we have trouble *inserting*
thead: table, tbody: table, tfoot: table, colgroup: table, caption: table
, tr: ['<table><tbody>', '</tbody></table>', 2]
, th: td , td: td
, col: ['<table><colgroup>', '</colgroup></table>', 2]
, fieldset: ['<form>', '</form>', 1]
, legend: ['<form><fieldset>', '</fieldset></form>', 2]
, option: option, optgroup: option
, script: noscope, style: noscope, link: noscope, param: noscope, base: noscope
}
, stateAttributes = /^(checked|selected|disabled)$/
, ie = /msie/i.test(navigator.userAgent)
, hasClass, addClass, removeClass
, uidMap = {}
, uuids = 0
, digit = /^-?[\d\.]+$/
, dattr = /^data-(.+)$/
, px = 'px'
, setAttribute = 'setAttribute'
, getAttribute = 'getAttribute'
, byTag = 'getElementsByTagName'
, features = function() {
var e = doc.createElement('p')
e.innerHTML = '<a href="#x">x</a><table style="float:left;"></table>'
return {
hrefExtended: e[byTag]('a')[0][getAttribute]('href') != '#x' // IE < 8
, autoTbody: e[byTag]('tbody').length !== 0 // IE < 8
, computedStyle: doc.defaultView && doc.defaultView.getComputedStyle
, cssFloat: e[byTag]('table')[0].style.styleFloat ? 'styleFloat' : 'cssFloat'
, transform: function () {
var props = ['webkitTransform', 'MozTransform', 'OTransform', 'msTransform', 'Transform'], i
for (i = 0; i < props.length; i++) {
if (props[i] in e.style) return props[i]
}
}()
, classList: 'classList' in e
, opasity: function () {
return typeof doc.createElement('a').style.opacity !== 'undefined'
}()
}
}()
, trimReplace = /(^\s*|\s*$)/g
, whitespaceRegex = /\s+/
, toString = String.prototype.toString
, unitless = { lineHeight: 1, zoom: 1, zIndex: 1, opacity: 1, boxFlex: 1, WebkitBoxFlex: 1, MozBoxFlex: 1 }
, trim = String.prototype.trim ?
function (s) {
return s.trim()
} :
function (s) {
return s.replace(trimReplace, '')
}
/**
* @param {string} c a class name to test
* @return {boolean}
*/
function classReg(c) {
return new RegExp("(^|\\s+)" + c + "(\\s+|$)")
}
/**
* @param {Bonzo|Array} ar
* @param {function(Object, number, (Bonzo|Array))} fn
* @param {Object=} opt_scope
* @param {boolean=} opt_rev
* @return {Bonzo|Array}
*/
function each(ar, fn, opt_scope, opt_rev) {
var ind, i = 0, l = ar.length
for (; i < l; i++) {
ind = opt_rev ? ar.length - i - 1 : i
fn.call(opt_scope || ar[ind], ar[ind], ind, ar)
}
return ar
}
/**
* @param {Bonzo|Array} ar
* @param {function(Object, number, (Bonzo|Array))} fn
* @param {Object=} opt_scope
* @return {Bonzo|Array}
*/
function deepEach(ar, fn, opt_scope) {
for (var i = 0, l = ar.length; i < l; i++) {
if (isNode(ar[i])) {
deepEach(ar[i].childNodes, fn, opt_scope)
fn.call(opt_scope || ar[i], ar[i], i, ar)
}
}
return ar
}
/**
* @param {string} s
* @return {string}
*/
function camelize(s) {
return s.replace(/-(.)/g, function (m, m1) {
return m1.toUpperCase()
})
}
/**
* @param {string} s
* @return