mirror of
https://github.com/hanzoai/daisho-riot.git
synced 2026-10-30 18:41:48 +00:00
16481 lines
1.5 MiB
Plaintext
16481 lines
1.5 MiB
Plaintext
(function (global) {
|
||
var process = {
|
||
title: 'browser',
|
||
browser: true,
|
||
env: {},
|
||
argv: [],
|
||
nextTick: function (fn) {
|
||
setTimeout(fn, 0)
|
||
},
|
||
cwd: function () {
|
||
return '/'
|
||
},
|
||
chdir: function () {
|
||
}
|
||
};
|
||
// Require module
|
||
function require(file, cb) {
|
||
// Handle async require
|
||
if (typeof cb == 'function') {
|
||
return require.load(file, cb)
|
||
}
|
||
// Return module from cache
|
||
if ({}.hasOwnProperty.call(require.cache, file))
|
||
return require.cache[file];
|
||
var resolved = require.resolve(file);
|
||
if (!resolved)
|
||
throw new Error('Failed to resolve module ' + file);
|
||
var mod = {
|
||
id: file,
|
||
require: require,
|
||
filename: file,
|
||
exports: {},
|
||
loaded: false,
|
||
parent: null,
|
||
children: []
|
||
};
|
||
var dirname = file.slice(0, file.lastIndexOf('/') + 1);
|
||
require.cache[file] = mod.exports;
|
||
resolved.call(mod.exports, mod, mod.exports, dirname, file, process);
|
||
mod.loaded = true;
|
||
return require.cache[file] = mod.exports
|
||
}
|
||
require.modules = {};
|
||
require.cache = {};
|
||
require.resolve = function (file) {
|
||
return {}.hasOwnProperty.call(require.modules, file) ? require.modules[file] : void 0
|
||
};
|
||
// define normal static module
|
||
require.define = function (file, fn) {
|
||
require.modules[file] = fn
|
||
};
|
||
require.waiting = {};
|
||
// Determine base path for all modules
|
||
var scripts = document.getElementsByTagName('script');
|
||
var file = scripts[scripts.length - 1].src;
|
||
require.basePath = file.slice(0, file.lastIndexOf('/') + 1);
|
||
// Generate URL for module
|
||
require.urlFor = function (file) {
|
||
var url = file.replace(/^\.?\//, '');
|
||
if (!/\.js$/.test(url))
|
||
url = url + '.js';
|
||
return require.basePath + url
|
||
};
|
||
// Load module async module
|
||
require.load = function (file, cb) {
|
||
// Immediately return previously loaded modules
|
||
if (require.modules[file] != null)
|
||
return cb(require(file));
|
||
// Build URL to request module at
|
||
var url = require.urlFor(file);
|
||
var script = document.createElement('script'), scripts = document.getElementsByTagName('script')[0], callbacks = require.waiting[file] = require.waiting[file] || [];
|
||
// We'll be called when async module is defined.
|
||
callbacks.push(cb);
|
||
// Load module
|
||
script.type = 'text/javascript';
|
||
script.async = true;
|
||
script.src = url;
|
||
script.file = file;
|
||
scripts.parentNode.insertBefore(script, scripts)
|
||
};
|
||
// Define async module
|
||
require.async = function (file, fn) {
|
||
require.modules[file] = fn;
|
||
var cb;
|
||
while (cb = require.waiting[file].shift())
|
||
cb(require(file))
|
||
};
|
||
global.require = require;
|
||
// source: src/controls/index.coffee
|
||
require.define('./controls', function (module, exports, __dirname, __filename, process) {
|
||
require('./controls/poly');
|
||
module.exports = {
|
||
Control: require('./controls/control'),
|
||
Text: require('./controls/text'),
|
||
InlineText: require('./controls/inline-text'),
|
||
StaticText: require('./controls/static-text'),
|
||
StaticDate: require('./controls/static-date'),
|
||
StaticAgo: require('./controls/static-ago'),
|
||
register: function (m) {
|
||
this.Text.register(m);
|
||
this.InlineText.register(m);
|
||
this.StaticText.register(m);
|
||
this.StaticDate.register(m);
|
||
return this.StaticAgo.register(m)
|
||
}
|
||
}
|
||
});
|
||
// source: src/controls/poly.coffee
|
||
require.define('./controls/poly', function (module, exports, __dirname, __filename, process) {
|
||
var riot;
|
||
riot = require('crowdcontrol/lib').riot.riot;
|
||
module.exports = riot.tag('daisho-poly-control', '', function (opts) {
|
||
var el, tag, tagEl;
|
||
if (opts.tag != null) {
|
||
tag = opts.tag;
|
||
delete opts.tag;
|
||
if (opts.optsOverride != null) {
|
||
opts = opts.optsOverride
|
||
}
|
||
el = document.createElement(tag);
|
||
this.root.appendChild(el);
|
||
opts.parent = this.parent;
|
||
tagEl = riot.mount(el, tag, opts)[0];
|
||
return tagEl.update()
|
||
}
|
||
})
|
||
});
|
||
// source: node_modules/crowdcontrol/lib/index.js
|
||
require.define('crowdcontrol/lib', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var CrowdControl, r, riot;
|
||
r = require('crowdcontrol/lib/riot');
|
||
riot = r();
|
||
CrowdControl = {
|
||
Views: require('crowdcontrol/lib/views'),
|
||
tags: [],
|
||
start: function (opts) {
|
||
return this.tags = riot.mount('*', opts)
|
||
},
|
||
update: function () {
|
||
var i, len, ref, results, tag;
|
||
ref = this.tags;
|
||
results = [];
|
||
for (i = 0, len = ref.length; i < len; i++) {
|
||
tag = ref[i];
|
||
results.push(tag.update())
|
||
}
|
||
return results
|
||
},
|
||
riot: r
|
||
};
|
||
if (module.exports != null) {
|
||
module.exports = CrowdControl
|
||
}
|
||
if (typeof window !== 'undefined' && window !== null) {
|
||
if (window.Crowdstart != null) {
|
||
window.Crowdstart.Crowdcontrol = CrowdControl
|
||
} else {
|
||
window.Crowdstart = { CrowdControl: CrowdControl }
|
||
}
|
||
} //# sourceMappingURL=index.js.map
|
||
});
|
||
// source: node_modules/crowdcontrol/lib/riot.js
|
||
require.define('crowdcontrol/lib/riot', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var r;
|
||
r = function () {
|
||
return this.riot
|
||
};
|
||
r.set = function (riot) {
|
||
this.riot = riot
|
||
};
|
||
r.riot = typeof window !== 'undefined' && window !== null ? window.riot : void 0;
|
||
module.exports = r //# sourceMappingURL=riot.js.map
|
||
});
|
||
// source: node_modules/crowdcontrol/lib/views/index.js
|
||
require.define('crowdcontrol/lib/views', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
module.exports = {
|
||
Form: require('crowdcontrol/lib/views/form'),
|
||
Input: require('crowdcontrol/lib/views/input'),
|
||
View: require('crowdcontrol/lib/views/view')
|
||
} //# sourceMappingURL=index.js.map
|
||
});
|
||
// source: node_modules/crowdcontrol/lib/views/form.js
|
||
require.define('crowdcontrol/lib/views/form', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Form, Promise, View, inputify, observable, settle, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
View = require('crowdcontrol/lib/views/view');
|
||
inputify = require('crowdcontrol/lib/views/inputify');
|
||
observable = require('crowdcontrol/lib/riot')().observable;
|
||
Promise = require('broken/lib');
|
||
settle = require('promise-settle');
|
||
Form = function (superClass) {
|
||
extend(Form, superClass);
|
||
function Form() {
|
||
return Form.__super__.constructor.apply(this, arguments)
|
||
}
|
||
Form.prototype.configs = null;
|
||
Form.prototype.inputs = null;
|
||
Form.prototype.data = null;
|
||
Form.prototype.initInputs = function () {
|
||
var input, name, ref, results1;
|
||
this.inputs = {};
|
||
if (this.configs != null) {
|
||
this.inputs = inputify(this.data, this.configs);
|
||
ref = this.inputs;
|
||
results1 = [];
|
||
for (name in ref) {
|
||
input = ref[name];
|
||
results1.push(observable(input))
|
||
}
|
||
return results1
|
||
}
|
||
};
|
||
Form.prototype.init = function () {
|
||
return this.initInputs()
|
||
};
|
||
Form.prototype.submit = function () {
|
||
var input, name, pRef, ps, ref;
|
||
ps = [];
|
||
ref = this.inputs;
|
||
for (name in ref) {
|
||
input = ref[name];
|
||
pRef = {};
|
||
input.trigger('validate', pRef);
|
||
ps.push(pRef.p)
|
||
}
|
||
return settle(ps).then(function (_this) {
|
||
return function (results) {
|
||
var i, len, result;
|
||
for (i = 0, len = results.length; i < len; i++) {
|
||
result = results[i];
|
||
if (!result.isFulfilled()) {
|
||
return
|
||
}
|
||
}
|
||
return _this._submit.apply(_this, arguments)
|
||
}
|
||
}(this))
|
||
};
|
||
Form.prototype._submit = function () {
|
||
};
|
||
return Form
|
||
}(View);
|
||
module.exports = Form //# sourceMappingURL=form.js.map
|
||
});
|
||
// source: node_modules/crowdcontrol/lib/views/view.js
|
||
require.define('crowdcontrol/lib/views/view', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var View, collapsePrototype, isFunction, objectAssign, riot, setPrototypeOf;
|
||
riot = require('crowdcontrol/lib/riot')();
|
||
objectAssign = require('object-assign');
|
||
setPrototypeOf = function () {
|
||
var mixinProperties, setProtoOf;
|
||
setProtoOf = function (obj, proto) {
|
||
return obj.__proto__ = proto
|
||
};
|
||
mixinProperties = function (obj, proto) {
|
||
var prop, results;
|
||
results = [];
|
||
for (prop in proto) {
|
||
if (obj[prop] == null) {
|
||
results.push(obj[prop] = proto[prop])
|
||
} else {
|
||
results.push(void 0)
|
||
}
|
||
}
|
||
return results
|
||
};
|
||
if (Object.setPrototypeOf || { __proto__: [] } instanceof Array) {
|
||
return setProtoOf
|
||
} else {
|
||
return mixinProperties
|
||
}
|
||
}();
|
||
isFunction = require('is-function');
|
||
collapsePrototype = function (collapse, proto) {
|
||
var parentProto;
|
||
if (proto === View.prototype) {
|
||
return
|
||
}
|
||
parentProto = Object.getPrototypeOf(proto);
|
||
collapsePrototype(collapse, parentProto);
|
||
return objectAssign(collapse, parentProto)
|
||
};
|
||
View = function () {
|
||
View.register = function () {
|
||
return new this
|
||
};
|
||
View.prototype.tag = '';
|
||
View.prototype.html = '';
|
||
View.prototype.css = '';
|
||
View.prototype.attrs = '';
|
||
View.prototype.events = null;
|
||
function View() {
|
||
var newProto;
|
||
newProto = collapsePrototype({}, this);
|
||
this.beforeInit();
|
||
riot.tag(this.tag, this.html, this.css, this.attrs, function (opts) {
|
||
var fn, handler, k, name, parent, proto, ref, ref1, self, v;
|
||
if (newProto != null) {
|
||
for (k in newProto) {
|
||
v = newProto[k];
|
||
if (isFunction(v)) {
|
||
(function (_this) {
|
||
return function (v) {
|
||
var oldFn;
|
||
if (_this[k] != null) {
|
||
oldFn = _this[k];
|
||
return _this[k] = function () {
|
||
oldFn.apply(_this, arguments);
|
||
return v.apply(_this, arguments)
|
||
}
|
||
} else {
|
||
return _this[k] = function () {
|
||
return v.apply(_this, arguments)
|
||
}
|
||
}
|
||
}
|
||
}(this)(v))
|
||
} else {
|
||
this[k] = v
|
||
}
|
||
}
|
||
}
|
||
self = this;
|
||
parent = (ref = self.parent) != null ? ref : opts.parent;
|
||
proto = Object.getPrototypeOf(self);
|
||
while (parent != null && parent !== proto) {
|
||
setPrototypeOf(self, parent);
|
||
self = parent;
|
||
parent = self.parent;
|
||
proto = Object.getPrototypeOf(self)
|
||
}
|
||
if (opts != null) {
|
||
for (k in opts) {
|
||
v = opts[k];
|
||
this[k] = v
|
||
}
|
||
}
|
||
if (this.events != null) {
|
||
ref1 = this.events;
|
||
fn = function (_this) {
|
||
return function (name, handler) {
|
||
if (typeof handler === 'string') {
|
||
return _this.on(name, function () {
|
||
return _this[handler].apply(_this, arguments)
|
||
})
|
||
} else {
|
||
return _this.on(name, function () {
|
||
return handler.apply(_this, arguments)
|
||
})
|
||
}
|
||
}
|
||
}(this);
|
||
for (name in ref1) {
|
||
handler = ref1[name];
|
||
fn(name, handler)
|
||
}
|
||
}
|
||
return this.init(opts)
|
||
})
|
||
}
|
||
View.prototype.beforeInit = function () {
|
||
};
|
||
View.prototype.init = function () {
|
||
};
|
||
return View
|
||
}();
|
||
module.exports = View //# sourceMappingURL=view.js.map
|
||
});
|
||
// source: node_modules/object-assign/index.js
|
||
require.define('object-assign', function (module, exports, __dirname, __filename, process) {
|
||
/* eslint-disable no-unused-vars */
|
||
'use strict';
|
||
var hasOwnProperty = Object.prototype.hasOwnProperty;
|
||
var propIsEnumerable = Object.prototype.propertyIsEnumerable;
|
||
function toObject(val) {
|
||
if (val === null || val === undefined) {
|
||
throw new TypeError('Object.assign cannot be called with null or undefined')
|
||
}
|
||
return Object(val)
|
||
}
|
||
module.exports = Object.assign || function (target, source) {
|
||
var from;
|
||
var to = toObject(target);
|
||
var symbols;
|
||
for (var s = 1; s < arguments.length; s++) {
|
||
from = Object(arguments[s]);
|
||
for (var key in from) {
|
||
if (hasOwnProperty.call(from, key)) {
|
||
to[key] = from[key]
|
||
}
|
||
}
|
||
if (Object.getOwnPropertySymbols) {
|
||
symbols = Object.getOwnPropertySymbols(from);
|
||
for (var i = 0; i < symbols.length; i++) {
|
||
if (propIsEnumerable.call(from, symbols[i])) {
|
||
to[symbols[i]] = from[symbols[i]]
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return to
|
||
}
|
||
});
|
||
// source: node_modules/is-function/index.js
|
||
require.define('is-function', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = isFunction;
|
||
var toString = Object.prototype.toString;
|
||
function isFunction(fn) {
|
||
var string = toString.call(fn);
|
||
return string === '[object Function]' || typeof fn === 'function' && string !== '[object RegExp]' || typeof window !== 'undefined' && (fn === window.setTimeout || fn === window.alert || fn === window.confirm || fn === window.prompt)
|
||
}
|
||
;
|
||
});
|
||
// source: node_modules/crowdcontrol/lib/views/inputify.js
|
||
require.define('crowdcontrol/lib/views/inputify', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Promise, inputify, isFunction, isRef, refer;
|
||
Promise = require('broken/lib');
|
||
isFunction = require('is-function');
|
||
refer = require('referential/lib');
|
||
isRef = function (o) {
|
||
return o != null && isFunction(o.ref)
|
||
};
|
||
inputify = function (data, configs) {
|
||
var config, fn, inputs, name, ref;
|
||
ref = data;
|
||
if (!isRef(ref)) {
|
||
ref = refer(data)
|
||
}
|
||
inputs = {};
|
||
fn = function (name, config) {
|
||
var fn1, i, input, len, middleware, middlewareFn, validate;
|
||
middleware = [];
|
||
if (config && config.length > 0) {
|
||
fn1 = function (name, middlewareFn) {
|
||
return middleware.push(function (pair) {
|
||
ref = pair[0], name = pair[1];
|
||
return Promise.resolve(pair).then(function (pair) {
|
||
return middlewareFn.call(pair[0], pair[0].get(pair[1]), pair[1], pair[0])
|
||
}).then(function (v) {
|
||
ref.set(name, v);
|
||
return pair
|
||
})
|
||
})
|
||
};
|
||
for (i = 0, len = config.length; i < len; i++) {
|
||
middlewareFn = config[i];
|
||
fn1(name, middlewareFn)
|
||
}
|
||
}
|
||
middleware.push(function (pair) {
|
||
ref = pair[0], name = pair[1];
|
||
return Promise.resolve(ref.get(name))
|
||
});
|
||
validate = function (ref, name) {
|
||
var j, len1, p;
|
||
p = Promise.resolve([
|
||
ref,
|
||
name
|
||
]);
|
||
for (j = 0, len1 = middleware.length; j < len1; j++) {
|
||
middlewareFn = middleware[j];
|
||
p = p.then(middlewareFn)
|
||
}
|
||
return p
|
||
};
|
||
input = {
|
||
name: name,
|
||
ref: ref,
|
||
config: config,
|
||
validate: validate
|
||
};
|
||
return inputs[name] = input
|
||
};
|
||
for (name in configs) {
|
||
config = configs[name];
|
||
fn(name, config)
|
||
}
|
||
return inputs
|
||
};
|
||
module.exports = inputify //# sourceMappingURL=inputify.js.map
|
||
});
|
||
// source: node_modules/broken/lib/index.js
|
||
require.define('broken/lib', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Promise, PromiseInspection;
|
||
Promise = require('zousan/zousan-min');
|
||
Promise.suppressUncaughtRejectionError = false;
|
||
PromiseInspection = function () {
|
||
function PromiseInspection(arg) {
|
||
this.state = arg.state, this.value = arg.value, this.reason = arg.reason
|
||
}
|
||
PromiseInspection.prototype.isFulfilled = function () {
|
||
return this.state === 'fulfilled'
|
||
};
|
||
PromiseInspection.prototype.isRejected = function () {
|
||
return this.state === 'rejected'
|
||
};
|
||
return PromiseInspection
|
||
}();
|
||
Promise.reflect = function (promise) {
|
||
return new Promise(function (resolve, reject) {
|
||
return promise.then(function (value) {
|
||
return resolve(new PromiseInspection({
|
||
state: 'fulfilled',
|
||
value: value
|
||
}))
|
||
})['catch'](function (err) {
|
||
return resolve(new PromiseInspection({
|
||
state: 'rejected',
|
||
reason: err
|
||
}))
|
||
})
|
||
})
|
||
};
|
||
Promise.settle = function (promises) {
|
||
return Promise.all(promises.map(Promise.reflect))
|
||
};
|
||
Promise.prototype.callback = function (cb) {
|
||
if (typeof cb === 'function') {
|
||
this.then(function (value) {
|
||
return cb(null, value)
|
||
});
|
||
this['catch'](function (error) {
|
||
return cb(error, null)
|
||
})
|
||
}
|
||
return this
|
||
};
|
||
module.exports = Promise //# sourceMappingURL=index.js.map
|
||
});
|
||
// source: node_modules/zousan/zousan-min.js
|
||
require.define('zousan/zousan-min', function (module, exports, __dirname, __filename, process) {
|
||
!function (t) {
|
||
'use strict';
|
||
function e(t) {
|
||
if (t) {
|
||
var e = this;
|
||
t(function (t) {
|
||
e.resolve(t)
|
||
}, function (t) {
|
||
e.reject(t)
|
||
})
|
||
}
|
||
}
|
||
function n(t, e) {
|
||
if ('function' == typeof t.y)
|
||
try {
|
||
var n = t.y.call(i, e);
|
||
t.p.resolve(n)
|
||
} catch (o) {
|
||
t.p.reject(o)
|
||
}
|
||
else
|
||
t.p.resolve(e)
|
||
}
|
||
function o(t, e) {
|
||
if ('function' == typeof t.n)
|
||
try {
|
||
var n = t.n.call(i, e);
|
||
t.p.resolve(n)
|
||
} catch (o) {
|
||
t.p.reject(o)
|
||
}
|
||
else
|
||
t.p.reject(e)
|
||
}
|
||
var r, i, c = 'fulfilled', u = 'rejected', s = 'undefined', f = function () {
|
||
function t() {
|
||
for (; e.length - n;)
|
||
e[n](), e[n++] = i, n == o && (e.splice(0, o), n = 0)
|
||
}
|
||
var e = [], n = 0, o = 1024, r = function () {
|
||
if (typeof MutationObserver !== s) {
|
||
var e = document.createElement('div'), n = new MutationObserver(t);
|
||
return n.observe(e, { attributes: !0 }), function () {
|
||
e.setAttribute('a', 0)
|
||
}
|
||
}
|
||
return typeof setImmediate !== s ? function () {
|
||
setImmediate(t)
|
||
} : function () {
|
||
setTimeout(t, 0)
|
||
}
|
||
}();
|
||
return function (t) {
|
||
e.push(t), e.length - n == 1 && r()
|
||
}
|
||
}();
|
||
e.prototype = {
|
||
resolve: function (t) {
|
||
if (this.state === r) {
|
||
if (t === this)
|
||
return this.reject(new TypeError('Attempt to resolve promise with self'));
|
||
var e = this;
|
||
if (t && ('function' == typeof t || 'object' == typeof t))
|
||
try {
|
||
var o = !0, i = t.then;
|
||
if ('function' == typeof i)
|
||
return void i.call(t, function (t) {
|
||
o && (o = !1, e.resolve(t))
|
||
}, function (t) {
|
||
o && (o = !1, e.reject(t))
|
||
})
|
||
} catch (u) {
|
||
return void (o && this.reject(u))
|
||
}
|
||
this.state = c, this.v = t, e.c && f(function () {
|
||
for (var o = 0, r = e.c.length; r > o; o++)
|
||
n(e.c[o], t)
|
||
})
|
||
}
|
||
},
|
||
reject: function (t) {
|
||
if (this.state === r) {
|
||
this.state = u, this.v = t;
|
||
var n = this.c;
|
||
n ? f(function () {
|
||
for (var e = 0, r = n.length; r > e; e++)
|
||
o(n[e], t)
|
||
}) : e.suppressUncaughtRejectionError || console.log('You upset Zousan. Please catch rejections: ', t, t.stack)
|
||
}
|
||
},
|
||
then: function (t, i) {
|
||
var u = new e, s = {
|
||
y: t,
|
||
n: i,
|
||
p: u
|
||
};
|
||
if (this.state === r)
|
||
this.c ? this.c.push(s) : this.c = [s];
|
||
else {
|
||
var l = this.state, a = this.v;
|
||
f(function () {
|
||
l === c ? n(s, a) : o(s, a)
|
||
})
|
||
}
|
||
return u
|
||
},
|
||
'catch': function (t) {
|
||
return this.then(null, t)
|
||
},
|
||
'finally': function (t) {
|
||
return this.then(t, t)
|
||
},
|
||
timeout: function (t, n) {
|
||
n = n || 'Timeout';
|
||
var o = this;
|
||
return new e(function (e, r) {
|
||
setTimeout(function () {
|
||
r(Error(n))
|
||
}, t), o.then(function (t) {
|
||
e(t)
|
||
}, function (t) {
|
||
r(t)
|
||
})
|
||
})
|
||
}
|
||
}, e.resolve = function (t) {
|
||
var n = new e;
|
||
return n.resolve(t), n
|
||
}, e.reject = function (t) {
|
||
var n = new e;
|
||
return n.reject(t), n
|
||
}, e.all = function (t) {
|
||
function n(n, c) {
|
||
'function' != typeof n.then && (n = e.resolve(n)), n.then(function (e) {
|
||
o[c] = e, r++, r == t.length && i.resolve(o)
|
||
}, function (t) {
|
||
i.reject(t)
|
||
})
|
||
}
|
||
for (var o = [], r = 0, i = new e, c = 0; c < t.length; c++)
|
||
n(t[c], c);
|
||
return t.length || i.resolve(o), i
|
||
}, typeof module != s && module.exports && (module.exports = e), t.Zousan = e, e.soon = f
|
||
}('undefined' != typeof global ? global : this)
|
||
});
|
||
// source: node_modules/referential/lib/index.js
|
||
require.define('referential/lib', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var refer;
|
||
refer = require('referential/lib/refer');
|
||
refer.Ref = require('referential/lib/ref');
|
||
module.exports = refer //# sourceMappingURL=index.js.map
|
||
});
|
||
// source: node_modules/referential/lib/refer.js
|
||
require.define('referential/lib/refer', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Ref, refer;
|
||
Ref = require('referential/lib/ref');
|
||
module.exports = refer = function (state, ref) {
|
||
var fn, i, len, method, ref1, wrapper;
|
||
if (ref == null) {
|
||
ref = null
|
||
}
|
||
if (ref == null) {
|
||
ref = new Ref(state)
|
||
}
|
||
wrapper = function (key) {
|
||
return ref.get(key)
|
||
};
|
||
ref1 = [
|
||
'value',
|
||
'get',
|
||
'set',
|
||
'extend',
|
||
'index',
|
||
'ref'
|
||
];
|
||
fn = function (method) {
|
||
return wrapper[method] = function () {
|
||
return ref[method].apply(ref, arguments)
|
||
}
|
||
};
|
||
for (i = 0, len = ref1.length; i < len; i++) {
|
||
method = ref1[i];
|
||
fn(method)
|
||
}
|
||
wrapper.refer = function (key) {
|
||
return refer(null, ref.ref(key))
|
||
};
|
||
wrapper.clone = function (key) {
|
||
return refer(null, ref.clone(key))
|
||
};
|
||
return wrapper
|
||
} //# sourceMappingURL=refer.js.map
|
||
});
|
||
// source: node_modules/referential/lib/ref.js
|
||
require.define('referential/lib/ref', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Ref, extend, isArray, isNumber, isObject, isString;
|
||
extend = require('node.extend');
|
||
isArray = require('is-array');
|
||
isNumber = require('is-number');
|
||
isObject = require('is-object');
|
||
isString = require('is-string');
|
||
module.exports = Ref = function () {
|
||
function Ref(_value, parent, key1) {
|
||
this._value = _value;
|
||
this.parent = parent;
|
||
this.key = key1;
|
||
this._cache = {}
|
||
}
|
||
Ref.prototype._mutate = function () {
|
||
return this._cache = {}
|
||
};
|
||
Ref.prototype.value = function (state) {
|
||
if (!this.parent) {
|
||
if (state != null) {
|
||
this._value = state
|
||
}
|
||
return this._value
|
||
}
|
||
if (state != null) {
|
||
return this.parent.set(this.key, state)
|
||
} else {
|
||
return this.parent.get(this.key)
|
||
}
|
||
};
|
||
Ref.prototype.ref = function (key) {
|
||
if (!key) {
|
||
return this
|
||
}
|
||
return new Ref(null, this, key)
|
||
};
|
||
Ref.prototype.get = function (key) {
|
||
if (!key) {
|
||
return this.value()
|
||
} else {
|
||
if (this._cache[key]) {
|
||
return this._cache[key]
|
||
}
|
||
return this._cache[key] = this.index(key)
|
||
}
|
||
};
|
||
Ref.prototype.set = function (key, value) {
|
||
this._mutate();
|
||
if (value == null) {
|
||
this.value(extend(this.value(), key))
|
||
} else {
|
||
this.index(key, value)
|
||
}
|
||
return this
|
||
};
|
||
Ref.prototype.extend = function (key, value) {
|
||
var clone;
|
||
this._mutate();
|
||
if (value == null) {
|
||
this.value(extend(true, this.value(), key))
|
||
} else {
|
||
if (isObject(value)) {
|
||
this.value(extend(true, this.ref(key).get(), value))
|
||
} else {
|
||
clone = this.clone();
|
||
this.set(key, value);
|
||
this.value(extend(true, clone.get(), this.value()))
|
||
}
|
||
}
|
||
return this
|
||
};
|
||
Ref.prototype.clone = function (key) {
|
||
return new Ref(extend(true, {}, this.get(key)))
|
||
};
|
||
Ref.prototype.index = function (key, value, obj, prev) {
|
||
var next, prop, props;
|
||
if (obj == null) {
|
||
obj = this.value()
|
||
}
|
||
if (this.parent) {
|
||
return this.parent.index(this.key + '.' + key, value)
|
||
}
|
||
if (isNumber(key)) {
|
||
key = String(key)
|
||
}
|
||
props = key.split('.');
|
||
if (value == null) {
|
||
while (prop = props.shift()) {
|
||
if (!props.length) {
|
||
return obj != null ? obj[prop] : void 0
|
||
}
|
||
obj = obj != null ? obj[prop] : void 0
|
||
}
|
||
return
|
||
}
|
||
while (prop = props.shift()) {
|
||
if (!props.length) {
|
||
return obj[prop] = value
|
||
} else {
|
||
next = props[0];
|
||
if (obj[next] == null) {
|
||
if (isNumber(next)) {
|
||
if (obj[prop] == null) {
|
||
obj[prop] = []
|
||
}
|
||
} else {
|
||
if (obj[prop] == null) {
|
||
obj[prop] = {}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
obj = obj[prop]
|
||
}
|
||
};
|
||
return Ref
|
||
}() //# sourceMappingURL=ref.js.map
|
||
});
|
||
// source: node_modules/node.extend/index.js
|
||
require.define('node.extend', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = require('node.extend/lib/extend')
|
||
});
|
||
// source: node_modules/node.extend/lib/extend.js
|
||
require.define('node.extend/lib/extend', function (module, exports, __dirname, __filename, process) {
|
||
/*!
|
||
* node.extend
|
||
* Copyright 2011, John Resig
|
||
* Dual licensed under the MIT or GPL Version 2 licenses.
|
||
* http://jquery.org/license
|
||
*
|
||
* @fileoverview
|
||
* Port of jQuery.extend that actually works on node.js
|
||
*/
|
||
var is = require('is');
|
||
function extend() {
|
||
var target = arguments[0] || {};
|
||
var i = 1;
|
||
var length = arguments.length;
|
||
var deep = false;
|
||
var options, name, src, copy, copy_is_array, clone;
|
||
// Handle a deep copy situation
|
||
if (typeof target === 'boolean') {
|
||
deep = target;
|
||
target = arguments[1] || {};
|
||
// skip the boolean and the target
|
||
i = 2
|
||
}
|
||
// Handle case when target is a string or something (possible in deep copy)
|
||
if (typeof target !== 'object' && !is.fn(target)) {
|
||
target = {}
|
||
}
|
||
for (; i < length; i++) {
|
||
// Only deal with non-null/undefined values
|
||
options = arguments[i];
|
||
if (options != null) {
|
||
if (typeof options === 'string') {
|
||
options = options.split('')
|
||
}
|
||
// Extend the base object
|
||
for (name in options) {
|
||
src = target[name];
|
||
copy = options[name];
|
||
// Prevent never-ending loop
|
||
if (target === copy) {
|
||
continue
|
||
}
|
||
// Recurse if we're merging plain objects or arrays
|
||
if (deep && copy && (is.hash(copy) || (copy_is_array = is.array(copy)))) {
|
||
if (copy_is_array) {
|
||
copy_is_array = false;
|
||
clone = src && is.array(src) ? src : []
|
||
} else {
|
||
clone = src && is.hash(src) ? src : {}
|
||
}
|
||
// Never move original objects, clone them
|
||
target[name] = extend(deep, clone, copy) // Don't bring in undefined values
|
||
} else if (typeof copy !== 'undefined') {
|
||
target[name] = copy
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Return the modified object
|
||
return target
|
||
}
|
||
;
|
||
/**
|
||
* @public
|
||
*/
|
||
extend.version = '1.1.3';
|
||
/**
|
||
* Exports module.
|
||
*/
|
||
module.exports = extend
|
||
});
|
||
// source: node_modules/is/index.js
|
||
require.define('is', function (module, exports, __dirname, __filename, process) {
|
||
/* globals window, HTMLElement */
|
||
/**!
|
||
* is
|
||
* the definitive JavaScript type testing library
|
||
*
|
||
* @copyright 2013-2014 Enrico Marino / Jordan Harband
|
||
* @license MIT
|
||
*/
|
||
var objProto = Object.prototype;
|
||
var owns = objProto.hasOwnProperty;
|
||
var toStr = objProto.toString;
|
||
var symbolValueOf;
|
||
if (typeof Symbol === 'function') {
|
||
symbolValueOf = Symbol.prototype.valueOf
|
||
}
|
||
var isActualNaN = function (value) {
|
||
return value !== value
|
||
};
|
||
var NON_HOST_TYPES = {
|
||
'boolean': 1,
|
||
number: 1,
|
||
string: 1,
|
||
undefined: 1
|
||
};
|
||
var base64Regex = /^([A-Za-z0-9+\/]{4})*([A-Za-z0-9+\/]{4}|[A-Za-z0-9+\/]{3}=|[A-Za-z0-9+\/]{2}==)$/;
|
||
var hexRegex = /^[A-Fa-f0-9]+$/;
|
||
/**
|
||
* Expose `is`
|
||
*/
|
||
var is = module.exports = {};
|
||
/**
|
||
* Test general.
|
||
*/
|
||
/**
|
||
* is.type
|
||
* Test if `value` is a type of `type`.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @param {String} type type
|
||
* @return {Boolean} true if `value` is a type of `type`, false otherwise
|
||
* @api public
|
||
*/
|
||
is.a = is.type = function (value, type) {
|
||
return typeof value === type
|
||
};
|
||
/**
|
||
* is.defined
|
||
* Test if `value` is defined.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if 'value' is defined, false otherwise
|
||
* @api public
|
||
*/
|
||
is.defined = function (value) {
|
||
return typeof value !== 'undefined'
|
||
};
|
||
/**
|
||
* is.empty
|
||
* Test if `value` is empty.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is empty, false otherwise
|
||
* @api public
|
||
*/
|
||
is.empty = function (value) {
|
||
var type = toStr.call(value);
|
||
var key;
|
||
if (type === '[object Array]' || type === '[object Arguments]' || type === '[object String]') {
|
||
return value.length === 0
|
||
}
|
||
if (type === '[object Object]') {
|
||
for (key in value) {
|
||
if (owns.call(value, key)) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
return !value
|
||
};
|
||
/**
|
||
* is.equal
|
||
* Test if `value` is equal to `other`.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @param {Mixed} other value to compare with
|
||
* @return {Boolean} true if `value` is equal to `other`, false otherwise
|
||
*/
|
||
is.equal = function equal(value, other) {
|
||
if (value === other) {
|
||
return true
|
||
}
|
||
var type = toStr.call(value);
|
||
var key;
|
||
if (type !== toStr.call(other)) {
|
||
return false
|
||
}
|
||
if (type === '[object Object]') {
|
||
for (key in value) {
|
||
if (!is.equal(value[key], other[key]) || !(key in other)) {
|
||
return false
|
||
}
|
||
}
|
||
for (key in other) {
|
||
if (!is.equal(value[key], other[key]) || !(key in value)) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
if (type === '[object Array]') {
|
||
key = value.length;
|
||
if (key !== other.length) {
|
||
return false
|
||
}
|
||
while (--key) {
|
||
if (!is.equal(value[key], other[key])) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
}
|
||
if (type === '[object Function]') {
|
||
return value.prototype === other.prototype
|
||
}
|
||
if (type === '[object Date]') {
|
||
return value.getTime() === other.getTime()
|
||
}
|
||
return false
|
||
};
|
||
/**
|
||
* is.hosted
|
||
* Test if `value` is hosted by `host`.
|
||
*
|
||
* @param {Mixed} value to test
|
||
* @param {Mixed} host host to test with
|
||
* @return {Boolean} true if `value` is hosted by `host`, false otherwise
|
||
* @api public
|
||
*/
|
||
is.hosted = function (value, host) {
|
||
var type = typeof host[value];
|
||
return type === 'object' ? !!host[value] : !NON_HOST_TYPES[type]
|
||
};
|
||
/**
|
||
* is.instance
|
||
* Test if `value` is an instance of `constructor`.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an instance of `constructor`
|
||
* @api public
|
||
*/
|
||
is.instance = is['instanceof'] = function (value, constructor) {
|
||
return value instanceof constructor
|
||
};
|
||
/**
|
||
* is.nil / is.null
|
||
* Test if `value` is null.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is null, false otherwise
|
||
* @api public
|
||
*/
|
||
is.nil = is['null'] = function (value) {
|
||
return value === null
|
||
};
|
||
/**
|
||
* is.undef / is.undefined
|
||
* Test if `value` is undefined.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is undefined, false otherwise
|
||
* @api public
|
||
*/
|
||
is.undef = is.undefined = function (value) {
|
||
return typeof value === 'undefined'
|
||
};
|
||
/**
|
||
* Test arguments.
|
||
*/
|
||
/**
|
||
* is.args
|
||
* Test if `value` is an arguments object.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an arguments object, false otherwise
|
||
* @api public
|
||
*/
|
||
is.args = is.arguments = function (value) {
|
||
var isStandardArguments = toStr.call(value) === '[object Arguments]';
|
||
var isOldArguments = !is.array(value) && is.arraylike(value) && is.object(value) && is.fn(value.callee);
|
||
return isStandardArguments || isOldArguments
|
||
};
|
||
/**
|
||
* Test array.
|
||
*/
|
||
/**
|
||
* is.array
|
||
* Test if 'value' is an array.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an array, false otherwise
|
||
* @api public
|
||
*/
|
||
is.array = Array.isArray || function (value) {
|
||
return toStr.call(value) === '[object Array]'
|
||
};
|
||
/**
|
||
* is.arguments.empty
|
||
* Test if `value` is an empty arguments object.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an empty arguments object, false otherwise
|
||
* @api public
|
||
*/
|
||
is.args.empty = function (value) {
|
||
return is.args(value) && value.length === 0
|
||
};
|
||
/**
|
||
* is.array.empty
|
||
* Test if `value` is an empty array.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an empty array, false otherwise
|
||
* @api public
|
||
*/
|
||
is.array.empty = function (value) {
|
||
return is.array(value) && value.length === 0
|
||
};
|
||
/**
|
||
* is.arraylike
|
||
* Test if `value` is an arraylike object.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an arguments object, false otherwise
|
||
* @api public
|
||
*/
|
||
is.arraylike = function (value) {
|
||
return !!value && !is.bool(value) && owns.call(value, 'length') && isFinite(value.length) && is.number(value.length) && value.length >= 0
|
||
};
|
||
/**
|
||
* Test boolean.
|
||
*/
|
||
/**
|
||
* is.bool
|
||
* Test if `value` is a boolean.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a boolean, false otherwise
|
||
* @api public
|
||
*/
|
||
is.bool = is['boolean'] = function (value) {
|
||
return toStr.call(value) === '[object Boolean]'
|
||
};
|
||
/**
|
||
* is.false
|
||
* Test if `value` is false.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is false, false otherwise
|
||
* @api public
|
||
*/
|
||
is['false'] = function (value) {
|
||
return is.bool(value) && Boolean(Number(value)) === false
|
||
};
|
||
/**
|
||
* is.true
|
||
* Test if `value` is true.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is true, false otherwise
|
||
* @api public
|
||
*/
|
||
is['true'] = function (value) {
|
||
return is.bool(value) && Boolean(Number(value)) === true
|
||
};
|
||
/**
|
||
* Test date.
|
||
*/
|
||
/**
|
||
* is.date
|
||
* Test if `value` is a date.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a date, false otherwise
|
||
* @api public
|
||
*/
|
||
is.date = function (value) {
|
||
return toStr.call(value) === '[object Date]'
|
||
};
|
||
/**
|
||
* Test element.
|
||
*/
|
||
/**
|
||
* is.element
|
||
* Test if `value` is an html element.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an HTML Element, false otherwise
|
||
* @api public
|
||
*/
|
||
is.element = function (value) {
|
||
return value !== undefined && typeof HTMLElement !== 'undefined' && value instanceof HTMLElement && value.nodeType === 1
|
||
};
|
||
/**
|
||
* Test error.
|
||
*/
|
||
/**
|
||
* is.error
|
||
* Test if `value` is an error object.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an error object, false otherwise
|
||
* @api public
|
||
*/
|
||
is.error = function (value) {
|
||
return toStr.call(value) === '[object Error]'
|
||
};
|
||
/**
|
||
* Test function.
|
||
*/
|
||
/**
|
||
* is.fn / is.function (deprecated)
|
||
* Test if `value` is a function.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a function, false otherwise
|
||
* @api public
|
||
*/
|
||
is.fn = is['function'] = function (value) {
|
||
var isAlert = typeof window !== 'undefined' && value === window.alert;
|
||
return isAlert || toStr.call(value) === '[object Function]'
|
||
};
|
||
/**
|
||
* Test number.
|
||
*/
|
||
/**
|
||
* is.number
|
||
* Test if `value` is a number.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a number, false otherwise
|
||
* @api public
|
||
*/
|
||
is.number = function (value) {
|
||
return toStr.call(value) === '[object Number]'
|
||
};
|
||
/**
|
||
* is.infinite
|
||
* Test if `value` is positive or negative infinity.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is positive or negative Infinity, false otherwise
|
||
* @api public
|
||
*/
|
||
is.infinite = function (value) {
|
||
return value === Infinity || value === -Infinity
|
||
};
|
||
/**
|
||
* is.decimal
|
||
* Test if `value` is a decimal number.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a decimal number, false otherwise
|
||
* @api public
|
||
*/
|
||
is.decimal = function (value) {
|
||
return is.number(value) && !isActualNaN(value) && !is.infinite(value) && value % 1 !== 0
|
||
};
|
||
/**
|
||
* is.divisibleBy
|
||
* Test if `value` is divisible by `n`.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Number} n dividend
|
||
* @return {Boolean} true if `value` is divisible by `n`, false otherwise
|
||
* @api public
|
||
*/
|
||
is.divisibleBy = function (value, n) {
|
||
var isDividendInfinite = is.infinite(value);
|
||
var isDivisorInfinite = is.infinite(n);
|
||
var isNonZeroNumber = is.number(value) && !isActualNaN(value) && is.number(n) && !isActualNaN(n) && n !== 0;
|
||
return isDividendInfinite || isDivisorInfinite || isNonZeroNumber && value % n === 0
|
||
};
|
||
/**
|
||
* is.integer
|
||
* Test if `value` is an integer.
|
||
*
|
||
* @param value to test
|
||
* @return {Boolean} true if `value` is an integer, false otherwise
|
||
* @api public
|
||
*/
|
||
is.integer = is['int'] = function (value) {
|
||
return is.number(value) && !isActualNaN(value) && value % 1 === 0
|
||
};
|
||
/**
|
||
* is.maximum
|
||
* Test if `value` is greater than 'others' values.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Array} others values to compare with
|
||
* @return {Boolean} true if `value` is greater than `others` values
|
||
* @api public
|
||
*/
|
||
is.maximum = function (value, others) {
|
||
if (isActualNaN(value)) {
|
||
throw new TypeError('NaN is not a valid value')
|
||
} else if (!is.arraylike(others)) {
|
||
throw new TypeError('second argument must be array-like')
|
||
}
|
||
var len = others.length;
|
||
while (--len >= 0) {
|
||
if (value < others[len]) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
};
|
||
/**
|
||
* is.minimum
|
||
* Test if `value` is less than `others` values.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Array} others values to compare with
|
||
* @return {Boolean} true if `value` is less than `others` values
|
||
* @api public
|
||
*/
|
||
is.minimum = function (value, others) {
|
||
if (isActualNaN(value)) {
|
||
throw new TypeError('NaN is not a valid value')
|
||
} else if (!is.arraylike(others)) {
|
||
throw new TypeError('second argument must be array-like')
|
||
}
|
||
var len = others.length;
|
||
while (--len >= 0) {
|
||
if (value > others[len]) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
};
|
||
/**
|
||
* is.nan
|
||
* Test if `value` is not a number.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is not a number, false otherwise
|
||
* @api public
|
||
*/
|
||
is.nan = function (value) {
|
||
return !is.number(value) || value !== value
|
||
};
|
||
/**
|
||
* is.even
|
||
* Test if `value` is an even number.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @return {Boolean} true if `value` is an even number, false otherwise
|
||
* @api public
|
||
*/
|
||
is.even = function (value) {
|
||
return is.infinite(value) || is.number(value) && value === value && value % 2 === 0
|
||
};
|
||
/**
|
||
* is.odd
|
||
* Test if `value` is an odd number.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @return {Boolean} true if `value` is an odd number, false otherwise
|
||
* @api public
|
||
*/
|
||
is.odd = function (value) {
|
||
return is.infinite(value) || is.number(value) && value === value && value % 2 !== 0
|
||
};
|
||
/**
|
||
* is.ge
|
||
* Test if `value` is greater than or equal to `other`.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Number} other value to compare with
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
is.ge = function (value, other) {
|
||
if (isActualNaN(value) || isActualNaN(other)) {
|
||
throw new TypeError('NaN is not a valid value')
|
||
}
|
||
return !is.infinite(value) && !is.infinite(other) && value >= other
|
||
};
|
||
/**
|
||
* is.gt
|
||
* Test if `value` is greater than `other`.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Number} other value to compare with
|
||
* @return {Boolean}
|
||
* @api public
|
||
*/
|
||
is.gt = function (value, other) {
|
||
if (isActualNaN(value) || isActualNaN(other)) {
|
||
throw new TypeError('NaN is not a valid value')
|
||
}
|
||
return !is.infinite(value) && !is.infinite(other) && value > other
|
||
};
|
||
/**
|
||
* is.le
|
||
* Test if `value` is less than or equal to `other`.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Number} other value to compare with
|
||
* @return {Boolean} if 'value' is less than or equal to 'other'
|
||
* @api public
|
||
*/
|
||
is.le = function (value, other) {
|
||
if (isActualNaN(value) || isActualNaN(other)) {
|
||
throw new TypeError('NaN is not a valid value')
|
||
}
|
||
return !is.infinite(value) && !is.infinite(other) && value <= other
|
||
};
|
||
/**
|
||
* is.lt
|
||
* Test if `value` is less than `other`.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Number} other value to compare with
|
||
* @return {Boolean} if `value` is less than `other`
|
||
* @api public
|
||
*/
|
||
is.lt = function (value, other) {
|
||
if (isActualNaN(value) || isActualNaN(other)) {
|
||
throw new TypeError('NaN is not a valid value')
|
||
}
|
||
return !is.infinite(value) && !is.infinite(other) && value < other
|
||
};
|
||
/**
|
||
* is.within
|
||
* Test if `value` is within `start` and `finish`.
|
||
*
|
||
* @param {Number} value value to test
|
||
* @param {Number} start lower bound
|
||
* @param {Number} finish upper bound
|
||
* @return {Boolean} true if 'value' is is within 'start' and 'finish'
|
||
* @api public
|
||
*/
|
||
is.within = function (value, start, finish) {
|
||
if (isActualNaN(value) || isActualNaN(start) || isActualNaN(finish)) {
|
||
throw new TypeError('NaN is not a valid value')
|
||
} else if (!is.number(value) || !is.number(start) || !is.number(finish)) {
|
||
throw new TypeError('all arguments must be numbers')
|
||
}
|
||
var isAnyInfinite = is.infinite(value) || is.infinite(start) || is.infinite(finish);
|
||
return isAnyInfinite || value >= start && value <= finish
|
||
};
|
||
/**
|
||
* Test object.
|
||
*/
|
||
/**
|
||
* is.object
|
||
* Test if `value` is an object.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is an object, false otherwise
|
||
* @api public
|
||
*/
|
||
is.object = function (value) {
|
||
return toStr.call(value) === '[object Object]'
|
||
};
|
||
/**
|
||
* is.hash
|
||
* Test if `value` is a hash - a plain object literal.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a hash, false otherwise
|
||
* @api public
|
||
*/
|
||
is.hash = function (value) {
|
||
return is.object(value) && value.constructor === Object && !value.nodeType && !value.setInterval
|
||
};
|
||
/**
|
||
* Test regexp.
|
||
*/
|
||
/**
|
||
* is.regexp
|
||
* Test if `value` is a regular expression.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a regexp, false otherwise
|
||
* @api public
|
||
*/
|
||
is.regexp = function (value) {
|
||
return toStr.call(value) === '[object RegExp]'
|
||
};
|
||
/**
|
||
* Test string.
|
||
*/
|
||
/**
|
||
* is.string
|
||
* Test if `value` is a string.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if 'value' is a string, false otherwise
|
||
* @api public
|
||
*/
|
||
is.string = function (value) {
|
||
return toStr.call(value) === '[object String]'
|
||
};
|
||
/**
|
||
* Test base64 string.
|
||
*/
|
||
/**
|
||
* is.base64
|
||
* Test if `value` is a valid base64 encoded string.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if 'value' is a base64 encoded string, false otherwise
|
||
* @api public
|
||
*/
|
||
is.base64 = function (value) {
|
||
return is.string(value) && (!value.length || base64Regex.test(value))
|
||
};
|
||
/**
|
||
* Test base64 string.
|
||
*/
|
||
/**
|
||
* is.hex
|
||
* Test if `value` is a valid hex encoded string.
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if 'value' is a hex encoded string, false otherwise
|
||
* @api public
|
||
*/
|
||
is.hex = function (value) {
|
||
return is.string(value) && (!value.length || hexRegex.test(value))
|
||
};
|
||
/**
|
||
* is.symbol
|
||
* Test if `value` is an ES6 Symbol
|
||
*
|
||
* @param {Mixed} value value to test
|
||
* @return {Boolean} true if `value` is a Symbol, false otherise
|
||
* @api public
|
||
*/
|
||
is.symbol = function (value) {
|
||
return typeof Symbol === 'function' && toStr.call(value) === '[object Symbol]' && typeof symbolValueOf.call(value) === 'symbol'
|
||
}
|
||
});
|
||
// source: node_modules/is-array/index.js
|
||
require.define('is-array', function (module, exports, __dirname, __filename, process) {
|
||
/**
|
||
* isArray
|
||
*/
|
||
var isArray = Array.isArray;
|
||
/**
|
||
* toString
|
||
*/
|
||
var str = Object.prototype.toString;
|
||
/**
|
||
* Whether or not the given `val`
|
||
* is an array.
|
||
*
|
||
* example:
|
||
*
|
||
* isArray([]);
|
||
* // > true
|
||
* isArray(arguments);
|
||
* // > false
|
||
* isArray('');
|
||
* // > false
|
||
*
|
||
* @param {mixed} val
|
||
* @return {bool}
|
||
*/
|
||
module.exports = isArray || function (val) {
|
||
return !!val && '[object Array]' == str.call(val)
|
||
}
|
||
});
|
||
// source: node_modules/is-number/index.js
|
||
require.define('is-number', function (module, exports, __dirname, __filename, process) {
|
||
/*!
|
||
* is-number <https://github.com/jonschlinkert/is-number>
|
||
*
|
||
* Copyright (c) 2014-2015, Jon Schlinkert.
|
||
* Licensed under the MIT License.
|
||
*/
|
||
'use strict';
|
||
var typeOf = require('kind-of');
|
||
module.exports = function isNumber(num) {
|
||
var type = typeOf(num);
|
||
if (type !== 'number' && type !== 'string') {
|
||
return false
|
||
}
|
||
var n = +num;
|
||
return n - n + 1 >= 0 && num !== ''
|
||
}
|
||
});
|
||
// source: node_modules/kind-of/index.js
|
||
require.define('kind-of', function (module, exports, __dirname, __filename, process) {
|
||
var isBuffer = require('is-buffer');
|
||
var toString = Object.prototype.toString;
|
||
/**
|
||
* Get the native `typeof` a value.
|
||
*
|
||
* @param {*} `val`
|
||
* @return {*} Native javascript type
|
||
*/
|
||
module.exports = function kindOf(val) {
|
||
// primitivies
|
||
if (typeof val === 'undefined') {
|
||
return 'undefined'
|
||
}
|
||
if (val === null) {
|
||
return 'null'
|
||
}
|
||
if (val === true || val === false || val instanceof Boolean) {
|
||
return 'boolean'
|
||
}
|
||
if (typeof val === 'string' || val instanceof String) {
|
||
return 'string'
|
||
}
|
||
if (typeof val === 'number' || val instanceof Number) {
|
||
return 'number'
|
||
}
|
||
// functions
|
||
if (typeof val === 'function' || val instanceof Function) {
|
||
return 'function'
|
||
}
|
||
// array
|
||
if (typeof Array.isArray !== 'undefined' && Array.isArray(val)) {
|
||
return 'array'
|
||
}
|
||
// check for instances of RegExp and Date before calling `toString`
|
||
if (val instanceof RegExp) {
|
||
return 'regexp'
|
||
}
|
||
if (val instanceof Date) {
|
||
return 'date'
|
||
}
|
||
// other objects
|
||
var type = toString.call(val);
|
||
if (type === '[object RegExp]') {
|
||
return 'regexp'
|
||
}
|
||
if (type === '[object Date]') {
|
||
return 'date'
|
||
}
|
||
if (type === '[object Arguments]') {
|
||
return 'arguments'
|
||
}
|
||
// buffer
|
||
if (typeof Buffer !== 'undefined' && isBuffer(val)) {
|
||
return 'buffer'
|
||
}
|
||
// es6: Map, WeakMap, Set, WeakSet
|
||
if (type === '[object Set]') {
|
||
return 'set'
|
||
}
|
||
if (type === '[object WeakSet]') {
|
||
return 'weakset'
|
||
}
|
||
if (type === '[object Map]') {
|
||
return 'map'
|
||
}
|
||
if (type === '[object WeakMap]') {
|
||
return 'weakmap'
|
||
}
|
||
if (type === '[object Symbol]') {
|
||
return 'symbol'
|
||
}
|
||
// typed arrays
|
||
if (type === '[object Int8Array]') {
|
||
return 'int8array'
|
||
}
|
||
if (type === '[object Uint8Array]') {
|
||
return 'uint8array'
|
||
}
|
||
if (type === '[object Uint8ClampedArray]') {
|
||
return 'uint8clampedarray'
|
||
}
|
||
if (type === '[object Int16Array]') {
|
||
return 'int16array'
|
||
}
|
||
if (type === '[object Uint16Array]') {
|
||
return 'uint16array'
|
||
}
|
||
if (type === '[object Int32Array]') {
|
||
return 'int32array'
|
||
}
|
||
if (type === '[object Uint32Array]') {
|
||
return 'uint32array'
|
||
}
|
||
if (type === '[object Float32Array]') {
|
||
return 'float32array'
|
||
}
|
||
if (type === '[object Float64Array]') {
|
||
return 'float64array'
|
||
}
|
||
// must be a plain object
|
||
return 'object'
|
||
}
|
||
});
|
||
// source: node_modules/is-buffer/index.js
|
||
require.define('is-buffer', function (module, exports, __dirname, __filename, process) {
|
||
/**
|
||
* Determine if an object is Buffer
|
||
*
|
||
* Author: Feross Aboukhadijeh <[email protected]> <http://feross.org>
|
||
* License: MIT
|
||
*
|
||
* `npm install is-buffer`
|
||
*/
|
||
module.exports = function (obj) {
|
||
return !!(obj != null && (obj._isBuffer || obj.constructor && typeof obj.constructor.isBuffer === 'function' && obj.constructor.isBuffer(obj)))
|
||
}
|
||
});
|
||
// source: node_modules/is-object/index.js
|
||
require.define('is-object', function (module, exports, __dirname, __filename, process) {
|
||
'use strict';
|
||
module.exports = function isObject(x) {
|
||
return typeof x === 'object' && x !== null
|
||
}
|
||
});
|
||
// source: node_modules/is-string/index.js
|
||
require.define('is-string', function (module, exports, __dirname, __filename, process) {
|
||
'use strict';
|
||
var strValue = String.prototype.valueOf;
|
||
var tryStringObject = function tryStringObject(value) {
|
||
try {
|
||
strValue.call(value);
|
||
return true
|
||
} catch (e) {
|
||
return false
|
||
}
|
||
};
|
||
var toStr = Object.prototype.toString;
|
||
var strClass = '[object String]';
|
||
var hasToStringTag = typeof Symbol === 'function' && typeof Symbol.toStringTag === 'symbol';
|
||
module.exports = function isString(value) {
|
||
if (typeof value === 'string') {
|
||
return true
|
||
}
|
||
if (typeof value !== 'object') {
|
||
return false
|
||
}
|
||
return hasToStringTag ? tryStringObject(value) : toStr.call(value) === strClass
|
||
}
|
||
});
|
||
// source: node_modules/promise-settle/index.js
|
||
require.define('promise-settle', function (module, exports, __dirname, __filename, process) {
|
||
'use strict';
|
||
module.exports = require('promise-settle/lib/promise-settle')
|
||
});
|
||
// source: node_modules/promise-settle/lib/promise-settle.js
|
||
require.define('promise-settle/lib/promise-settle', function (module, exports, __dirname, __filename, process) {
|
||
'use strict';
|
||
module.exports = settle;
|
||
function settle(promises) {
|
||
return Promise.resolve().then(function () {
|
||
return promises
|
||
}).then(function (promises) {
|
||
if (!Array.isArray(promises))
|
||
throw new TypeError('Expected an array of Promises');
|
||
var promiseResults = promises.map(function (promise) {
|
||
return Promise.resolve().then(function () {
|
||
return promise
|
||
}).then(function (result) {
|
||
return promiseResult(result)
|
||
}).catch(function (err) {
|
||
return promiseResult(null, err)
|
||
})
|
||
});
|
||
return Promise.all(promiseResults)
|
||
})
|
||
}
|
||
function promiseResult(result, err) {
|
||
var isFulfilled = typeof err === 'undefined';
|
||
var value = isFulfilled ? returns.bind(result) : throws.bind(new Error('Promise is rejected'));
|
||
var isRejected = !isFulfilled;
|
||
var reason = isRejected ? returns.bind(err) : throws.bind(new Error('Promise is fulfilled'));
|
||
return {
|
||
isFulfilled: returns.bind(isFulfilled),
|
||
isRejected: returns.bind(isRejected),
|
||
value: value,
|
||
reason: reason
|
||
}
|
||
}
|
||
function returns() {
|
||
return this
|
||
}
|
||
function throws() {
|
||
throw this
|
||
}
|
||
});
|
||
// source: node_modules/crowdcontrol/lib/views/input.js
|
||
require.define('crowdcontrol/lib/views/input', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Input, View, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
View = require('crowdcontrol/lib/views/view');
|
||
Input = function (superClass) {
|
||
extend(Input, superClass);
|
||
function Input() {
|
||
return Input.__super__.constructor.apply(this, arguments)
|
||
}
|
||
Input.prototype.input = null;
|
||
Input.prototype.errorMessage = '';
|
||
Input.prototype.errorHtml = '<div class="error-container" if="{ errorMessage }">\n <div class="error-message">{ errorMessage }</div>\n</div>';
|
||
Input.prototype.beforeInit = function () {
|
||
return this.html += this.errorHtml
|
||
};
|
||
Input.prototype.init = function () {
|
||
return this.input.on('validate', function (_this) {
|
||
return function (pRef) {
|
||
return _this.validate(pRef)
|
||
}
|
||
}(this))
|
||
};
|
||
Input.prototype.getValue = function (event) {
|
||
return event.target.value
|
||
};
|
||
Input.prototype.change = function (event) {
|
||
var name, ref, ref1, value;
|
||
ref1 = this.input, ref = ref1.ref, name = ref1.name;
|
||
value = this.getValue(event);
|
||
if (value === ref.get(name)) {
|
||
return
|
||
}
|
||
this.input.ref.set(name, value);
|
||
this.clearError();
|
||
return this.validate()
|
||
};
|
||
Input.prototype.error = function (err) {
|
||
var ref1;
|
||
return this.errorMessage = (ref1 = err != null ? err.message : void 0) != null ? ref1 : err
|
||
};
|
||
Input.prototype.changed = function () {
|
||
};
|
||
Input.prototype.clearError = function () {
|
||
return this.errorMessage = ''
|
||
};
|
||
Input.prototype.validate = function (pRef) {
|
||
var p;
|
||
p = this.input.validate(this.input.ref, this.input.name).then(function (_this) {
|
||
return function (value) {
|
||
_this.changed(value);
|
||
return _this.update()
|
||
}
|
||
}(this))['catch'](function (_this) {
|
||
return function (err) {
|
||
_this.error(err);
|
||
_this.update();
|
||
throw err
|
||
}
|
||
}(this));
|
||
if (pRef != null) {
|
||
pRef.p = p
|
||
}
|
||
return p
|
||
};
|
||
return Input
|
||
}(View);
|
||
module.exports = Input //# sourceMappingURL=input.js.map
|
||
});
|
||
// source: src/controls/control.coffee
|
||
require.define('./controls/control', function (module, exports, __dirname, __filename, process) {
|
||
var $, Control, CrowdControl, Events, riot, scrolling, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
CrowdControl = require('crowdcontrol/lib');
|
||
Events = require('./events');
|
||
riot = require('crowdcontrol/lib').riot.riot;
|
||
$ = require('jquery/dist/jquery');
|
||
scrolling = false;
|
||
module.exports = Control = function (superClass) {
|
||
extend(Control, superClass);
|
||
function Control() {
|
||
return Control.__super__.constructor.apply(this, arguments)
|
||
}
|
||
Control.prototype.init = function () {
|
||
if (this.input == null && this.inputs != null) {
|
||
this.input = this.inputs[this.lookup]
|
||
}
|
||
if (this.input != null) {
|
||
return Control.__super__.init.apply(this, arguments)
|
||
}
|
||
};
|
||
Control.prototype.getValue = function (event) {
|
||
var ref;
|
||
return (ref = $(event.target).val()) != null ? ref.trim() : void 0
|
||
};
|
||
Control.prototype.error = function (err) {
|
||
var ref;
|
||
if (err instanceof DOMException) {
|
||
console.log('WARNING: Error in riot dom manipulation ignored.', err);
|
||
return
|
||
}
|
||
Control.__super__.error.apply(this, arguments);
|
||
if (!scrolling) {
|
||
scrolling = true;
|
||
$('html, body').animate({ scrollTop: $(this.root).offset().top - $(window).height() / 2 }, {
|
||
complete: function () {
|
||
return scrolling = false
|
||
},
|
||
duration: 500
|
||
})
|
||
}
|
||
if ((ref = this.m) != null) {
|
||
ref.trigger(Events.ChangeFailed, this.input.name, this.input.ref.get(this.input.name))
|
||
}
|
||
return this.input.trigger(Events.ChangeFailed, this.input.name, this.input.ref.get(this.input.name))
|
||
};
|
||
Control.prototype.change = function () {
|
||
var ref;
|
||
Control.__super__.change.apply(this, arguments);
|
||
if ((ref = this.m) != null) {
|
||
ref.trigger(Events.Change, this.input.name, this.input.ref.get(this.input.name))
|
||
}
|
||
return this.input.trigger(Events.Change, this.input.name, this.input.ref.get(this.input.name))
|
||
};
|
||
Control.prototype.changed = function (value) {
|
||
var ref;
|
||
if ((ref = this.m) != null) {
|
||
ref.trigger(Events.ChangeSuccess, this.input.name, value)
|
||
}
|
||
this.input.trigger(Events.ChangeSuccess, this.input.name, value);
|
||
return riot.update()
|
||
};
|
||
Control.register = function (m) {
|
||
var v;
|
||
v = Control.__super__.constructor.register.call(this);
|
||
return v.m = m
|
||
};
|
||
return Control
|
||
}(CrowdControl.Views.Input)
|
||
});
|
||
// source: src/events.coffee
|
||
require.define('./events', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = {
|
||
Change: 'change',
|
||
ChangeSuccess: 'change-success',
|
||
ChangeFailed: 'change-failed',
|
||
FilterChange: 'filter-change'
|
||
}
|
||
});
|
||
// source: node_modules/jquery/dist/jquery.js
|
||
require.define('jquery/dist/jquery', function (module, exports, __dirname, __filename, process) {
|
||
/*!
|
||
* jQuery JavaScript Library v2.2.2
|
||
* http://jquery.com/
|
||
*
|
||
* Includes Sizzle.js
|
||
* http://sizzlejs.com/
|
||
*
|
||
* Copyright jQuery Foundation and other contributors
|
||
* Released under the MIT license
|
||
* http://jquery.org/license
|
||
*
|
||
* Date: 2016-03-17T17:51Z
|
||
*/
|
||
(function (global, factory) {
|
||
if (typeof module === 'object' && typeof module.exports === 'object') {
|
||
// For CommonJS and CommonJS-like environments where a proper `window`
|
||
// is present, execute the factory and get jQuery.
|
||
// For environments that do not have a `window` with a `document`
|
||
// (such as Node.js), expose a factory as module.exports.
|
||
// This accentuates the need for the creation of a real `window`.
|
||
// e.g. var jQuery = require("jquery")(window);
|
||
// See ticket #14549 for more info.
|
||
module.exports = global.document ? factory(global, true) : function (w) {
|
||
if (!w.document) {
|
||
throw new Error('jQuery requires a window with a document')
|
||
}
|
||
return factory(w)
|
||
}
|
||
} else {
|
||
factory(global)
|
||
} // Pass this if window is not defined yet
|
||
}(typeof window !== 'undefined' ? window : this, function (window, noGlobal) {
|
||
// Support: Firefox 18+
|
||
// Can't be in strict mode, several libs including ASP.NET trace
|
||
// the stack via arguments.caller.callee and Firefox dies if
|
||
// you try to trace through "use strict" call chains. (#13335)
|
||
//"use strict";
|
||
var arr = [];
|
||
var document = window.document;
|
||
var slice = arr.slice;
|
||
var concat = arr.concat;
|
||
var push = arr.push;
|
||
var indexOf = arr.indexOf;
|
||
var class2type = {};
|
||
var toString = class2type.toString;
|
||
var hasOwn = class2type.hasOwnProperty;
|
||
var support = {};
|
||
var version = '2.2.2',
|
||
// Define a local copy of jQuery
|
||
jQuery = function (selector, context) {
|
||
// The jQuery object is actually just the init constructor 'enhanced'
|
||
// Need init if jQuery is called (just allow error to be thrown if not included)
|
||
return new jQuery.fn.init(selector, context)
|
||
},
|
||
// Support: Android<4.1
|
||
// Make sure we trim BOM and NBSP
|
||
rtrim = /^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g,
|
||
// Matches dashed string for camelizing
|
||
rmsPrefix = /^-ms-/, rdashAlpha = /-([\da-z])/gi,
|
||
// Used by jQuery.camelCase as callback to replace()
|
||
fcamelCase = function (all, letter) {
|
||
return letter.toUpperCase()
|
||
};
|
||
jQuery.fn = jQuery.prototype = {
|
||
// The current version of jQuery being used
|
||
jquery: version,
|
||
constructor: jQuery,
|
||
// Start with an empty selector
|
||
selector: '',
|
||
// The default length of a jQuery object is 0
|
||
length: 0,
|
||
toArray: function () {
|
||
return slice.call(this)
|
||
},
|
||
// Get the Nth element in the matched element set OR
|
||
// Get the whole matched element set as a clean array
|
||
get: function (num) {
|
||
return num != null ? num < 0 ? this[num + this.length] : this[num] : // Return all the elements in a clean array
|
||
slice.call(this)
|
||
},
|
||
// Take an array of elements and push it onto the stack
|
||
// (returning the new matched element set)
|
||
pushStack: function (elems) {
|
||
// Build a new jQuery matched element set
|
||
var ret = jQuery.merge(this.constructor(), elems);
|
||
// Add the old object onto the stack (as a reference)
|
||
ret.prevObject = this;
|
||
ret.context = this.context;
|
||
// Return the newly-formed element set
|
||
return ret
|
||
},
|
||
// Execute a callback for every element in the matched set.
|
||
each: function (callback) {
|
||
return jQuery.each(this, callback)
|
||
},
|
||
map: function (callback) {
|
||
return this.pushStack(jQuery.map(this, function (elem, i) {
|
||
return callback.call(elem, i, elem)
|
||
}))
|
||
},
|
||
slice: function () {
|
||
return this.pushStack(slice.apply(this, arguments))
|
||
},
|
||
first: function () {
|
||
return this.eq(0)
|
||
},
|
||
last: function () {
|
||
return this.eq(-1)
|
||
},
|
||
eq: function (i) {
|
||
var len = this.length, j = +i + (i < 0 ? len : 0);
|
||
return this.pushStack(j >= 0 && j < len ? [this[j]] : [])
|
||
},
|
||
end: function () {
|
||
return this.prevObject || this.constructor()
|
||
},
|
||
// For internal use only.
|
||
// Behaves like an Array's method, not like a jQuery method.
|
||
push: push,
|
||
sort: arr.sort,
|
||
splice: arr.splice
|
||
};
|
||
jQuery.extend = jQuery.fn.extend = function () {
|
||
var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length, deep = false;
|
||
// Handle a deep copy situation
|
||
if (typeof target === 'boolean') {
|
||
deep = target;
|
||
// Skip the boolean and the target
|
||
target = arguments[i] || {};
|
||
i++
|
||
}
|
||
// Handle case when target is a string or something (possible in deep copy)
|
||
if (typeof target !== 'object' && !jQuery.isFunction(target)) {
|
||
target = {}
|
||
}
|
||
// Extend jQuery itself if only one argument is passed
|
||
if (i === length) {
|
||
target = this;
|
||
i--
|
||
}
|
||
for (; i < length; i++) {
|
||
// Only deal with non-null/undefined values
|
||
if ((options = arguments[i]) != null) {
|
||
// Extend the base object
|
||
for (name in options) {
|
||
src = target[name];
|
||
copy = options[name];
|
||
// Prevent never-ending loop
|
||
if (target === copy) {
|
||
continue
|
||
}
|
||
// Recurse if we're merging plain objects or arrays
|
||
if (deep && copy && (jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)))) {
|
||
if (copyIsArray) {
|
||
copyIsArray = false;
|
||
clone = src && jQuery.isArray(src) ? src : []
|
||
} else {
|
||
clone = src && jQuery.isPlainObject(src) ? src : {}
|
||
}
|
||
// Never move original objects, clone them
|
||
target[name] = jQuery.extend(deep, clone, copy) // Don't bring in undefined values
|
||
} else if (copy !== undefined) {
|
||
target[name] = copy
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Return the modified object
|
||
return target
|
||
};
|
||
jQuery.extend({
|
||
// Unique for each copy of jQuery on the page
|
||
expando: 'jQuery' + (version + Math.random()).replace(/\D/g, ''),
|
||
// Assume jQuery is ready without the ready module
|
||
isReady: true,
|
||
error: function (msg) {
|
||
throw new Error(msg)
|
||
},
|
||
noop: function () {
|
||
},
|
||
isFunction: function (obj) {
|
||
return jQuery.type(obj) === 'function'
|
||
},
|
||
isArray: Array.isArray,
|
||
isWindow: function (obj) {
|
||
return obj != null && obj === obj.window
|
||
},
|
||
isNumeric: function (obj) {
|
||
// parseFloat NaNs numeric-cast false positives (null|true|false|"")
|
||
// ...but misinterprets leading-number strings, particularly hex literals ("0x...")
|
||
// subtraction forces infinities to NaN
|
||
// adding 1 corrects loss of precision from parseFloat (#15100)
|
||
var realStringObj = obj && obj.toString();
|
||
return !jQuery.isArray(obj) && realStringObj - parseFloat(realStringObj) + 1 >= 0
|
||
},
|
||
isPlainObject: function (obj) {
|
||
var key;
|
||
// Not plain objects:
|
||
// - Any object or value whose internal [[Class]] property is not "[object Object]"
|
||
// - DOM nodes
|
||
// - window
|
||
if (jQuery.type(obj) !== 'object' || obj.nodeType || jQuery.isWindow(obj)) {
|
||
return false
|
||
}
|
||
// Not own constructor property must be Object
|
||
if (obj.constructor && !hasOwn.call(obj, 'constructor') && !hasOwn.call(obj.constructor.prototype || {}, 'isPrototypeOf')) {
|
||
return false
|
||
}
|
||
// Own properties are enumerated firstly, so to speed up,
|
||
// if last one is own, then all properties are own
|
||
for (key in obj) {
|
||
}
|
||
return key === undefined || hasOwn.call(obj, key)
|
||
},
|
||
isEmptyObject: function (obj) {
|
||
var name;
|
||
for (name in obj) {
|
||
return false
|
||
}
|
||
return true
|
||
},
|
||
type: function (obj) {
|
||
if (obj == null) {
|
||
return obj + ''
|
||
}
|
||
// Support: Android<4.0, iOS<6 (functionish RegExp)
|
||
return typeof obj === 'object' || typeof obj === 'function' ? class2type[toString.call(obj)] || 'object' : typeof obj
|
||
},
|
||
// Evaluates a script in a global context
|
||
globalEval: function (code) {
|
||
var script, indirect = eval;
|
||
code = jQuery.trim(code);
|
||
if (code) {
|
||
// If the code includes a valid, prologue position
|
||
// strict mode pragma, execute code by injecting a
|
||
// script tag into the document.
|
||
if (code.indexOf('use strict') === 1) {
|
||
script = document.createElement('script');
|
||
script.text = code;
|
||
document.head.appendChild(script).parentNode.removeChild(script)
|
||
} else {
|
||
// Otherwise, avoid the DOM node creation, insertion
|
||
// and removal by using an indirect global eval
|
||
indirect(code)
|
||
}
|
||
}
|
||
},
|
||
// Convert dashed to camelCase; used by the css and data modules
|
||
// Support: IE9-11+
|
||
// Microsoft forgot to hump their vendor prefix (#9572)
|
||
camelCase: function (string) {
|
||
return string.replace(rmsPrefix, 'ms-').replace(rdashAlpha, fcamelCase)
|
||
},
|
||
nodeName: function (elem, name) {
|
||
return elem.nodeName && elem.nodeName.toLowerCase() === name.toLowerCase()
|
||
},
|
||
each: function (obj, callback) {
|
||
var length, i = 0;
|
||
if (isArrayLike(obj)) {
|
||
length = obj.length;
|
||
for (; i < length; i++) {
|
||
if (callback.call(obj[i], i, obj[i]) === false) {
|
||
break
|
||
}
|
||
}
|
||
} else {
|
||
for (i in obj) {
|
||
if (callback.call(obj[i], i, obj[i]) === false) {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return obj
|
||
},
|
||
// Support: Android<4.1
|
||
trim: function (text) {
|
||
return text == null ? '' : (text + '').replace(rtrim, '')
|
||
},
|
||
// results is for internal usage only
|
||
makeArray: function (arr, results) {
|
||
var ret = results || [];
|
||
if (arr != null) {
|
||
if (isArrayLike(Object(arr))) {
|
||
jQuery.merge(ret, typeof arr === 'string' ? [arr] : arr)
|
||
} else {
|
||
push.call(ret, arr)
|
||
}
|
||
}
|
||
return ret
|
||
},
|
||
inArray: function (elem, arr, i) {
|
||
return arr == null ? -1 : indexOf.call(arr, elem, i)
|
||
},
|
||
merge: function (first, second) {
|
||
var len = +second.length, j = 0, i = first.length;
|
||
for (; j < len; j++) {
|
||
first[i++] = second[j]
|
||
}
|
||
first.length = i;
|
||
return first
|
||
},
|
||
grep: function (elems, callback, invert) {
|
||
var callbackInverse, matches = [], i = 0, length = elems.length, callbackExpect = !invert;
|
||
// Go through the array, only saving the items
|
||
// that pass the validator function
|
||
for (; i < length; i++) {
|
||
callbackInverse = !callback(elems[i], i);
|
||
if (callbackInverse !== callbackExpect) {
|
||
matches.push(elems[i])
|
||
}
|
||
}
|
||
return matches
|
||
},
|
||
// arg is for internal usage only
|
||
map: function (elems, callback, arg) {
|
||
var length, value, i = 0, ret = [];
|
||
// Go through the array, translating each of the items to their new values
|
||
if (isArrayLike(elems)) {
|
||
length = elems.length;
|
||
for (; i < length; i++) {
|
||
value = callback(elems[i], i, arg);
|
||
if (value != null) {
|
||
ret.push(value)
|
||
}
|
||
} // Go through every key on the object,
|
||
} else {
|
||
for (i in elems) {
|
||
value = callback(elems[i], i, arg);
|
||
if (value != null) {
|
||
ret.push(value)
|
||
}
|
||
}
|
||
}
|
||
// Flatten any nested arrays
|
||
return concat.apply([], ret)
|
||
},
|
||
// A global GUID counter for objects
|
||
guid: 1,
|
||
// Bind a function to a context, optionally partially applying any
|
||
// arguments.
|
||
proxy: function (fn, context) {
|
||
var tmp, args, proxy;
|
||
if (typeof context === 'string') {
|
||
tmp = fn[context];
|
||
context = fn;
|
||
fn = tmp
|
||
}
|
||
// Quick check to determine if target is callable, in the spec
|
||
// this throws a TypeError, but we will just return undefined.
|
||
if (!jQuery.isFunction(fn)) {
|
||
return undefined
|
||
}
|
||
// Simulated bind
|
||
args = slice.call(arguments, 2);
|
||
proxy = function () {
|
||
return fn.apply(context || this, args.concat(slice.call(arguments)))
|
||
};
|
||
// Set the guid of unique handler to the same of original handler, so it can be removed
|
||
proxy.guid = fn.guid = fn.guid || jQuery.guid++;
|
||
return proxy
|
||
},
|
||
now: Date.now,
|
||
// jQuery.support is not used in Core but other projects attach their
|
||
// properties to it so it needs to exist.
|
||
support: support
|
||
});
|
||
// JSHint would error on this code due to the Symbol not being defined in ES5.
|
||
// Defining this global in .jshintrc would create a danger of using the global
|
||
// unguarded in another place, it seems safer to just disable JSHint for these
|
||
// three lines.
|
||
/* jshint ignore: start */
|
||
if (typeof Symbol === 'function') {
|
||
jQuery.fn[Symbol.iterator] = arr[Symbol.iterator]
|
||
}
|
||
/* jshint ignore: end */
|
||
// Populate the class2type map
|
||
jQuery.each('Boolean Number String Function Array Date RegExp Object Error Symbol'.split(' '), function (i, name) {
|
||
class2type['[object ' + name + ']'] = name.toLowerCase()
|
||
});
|
||
function isArrayLike(obj) {
|
||
// Support: iOS 8.2 (not reproducible in simulator)
|
||
// `in` check used to prevent JIT error (gh-2145)
|
||
// hasOwn isn't used here due to false negatives
|
||
// regarding Nodelist length in IE
|
||
var length = !!obj && 'length' in obj && obj.length, type = jQuery.type(obj);
|
||
if (type === 'function' || jQuery.isWindow(obj)) {
|
||
return false
|
||
}
|
||
return type === 'array' || length === 0 || typeof length === 'number' && length > 0 && length - 1 in obj
|
||
}
|
||
var Sizzle = /*!
|
||
* Sizzle CSS Selector Engine v2.2.1
|
||
* http://sizzlejs.com/
|
||
*
|
||
* Copyright jQuery Foundation and other contributors
|
||
* Released under the MIT license
|
||
* http://jquery.org/license
|
||
*
|
||
* Date: 2015-10-17
|
||
*/
|
||
function (window) {
|
||
var i, support, Expr, getText, isXML, tokenize, compile, select, outermostContext, sortInput, hasDuplicate,
|
||
// Local document vars
|
||
setDocument, document, docElem, documentIsHTML, rbuggyQSA, rbuggyMatches, matches, contains,
|
||
// Instance-specific data
|
||
expando = 'sizzle' + 1 * new Date, preferredDoc = window.document, dirruns = 0, done = 0, classCache = createCache(), tokenCache = createCache(), compilerCache = createCache(), sortOrder = function (a, b) {
|
||
if (a === b) {
|
||
hasDuplicate = true
|
||
}
|
||
return 0
|
||
},
|
||
// General-purpose constants
|
||
MAX_NEGATIVE = 1 << 31,
|
||
// Instance methods
|
||
hasOwn = {}.hasOwnProperty, arr = [], pop = arr.pop, push_native = arr.push, push = arr.push, slice = arr.slice,
|
||
// Use a stripped-down indexOf as it's faster than native
|
||
// http://jsperf.com/thor-indexof-vs-for/5
|
||
indexOf = function (list, elem) {
|
||
var i = 0, len = list.length;
|
||
for (; i < len; i++) {
|
||
if (list[i] === elem) {
|
||
return i
|
||
}
|
||
}
|
||
return -1
|
||
}, booleans = 'checked|selected|async|autofocus|autoplay|controls|defer|disabled|hidden|ismap|loop|multiple|open|readonly|required|scoped',
|
||
// Regular expressions
|
||
// http://www.w3.org/TR/css3-selectors/#whitespace
|
||
whitespace = '[\\x20\\t\\r\\n\\f]',
|
||
// http://www.w3.org/TR/CSS21/syndata.html#value-def-identifier
|
||
identifier = '(?:\\\\.|[\\w-]|[^\\x00-\\xa0])+',
|
||
// Attribute selectors: http://www.w3.org/TR/selectors/#attribute-selectors
|
||
attributes = '\\[' + whitespace + '*(' + identifier + ')(?:' + whitespace + // Operator (capture 2)
|
||
'*([*^$|!~]?=)' + whitespace + // "Attribute values must be CSS identifiers [capture 5] or strings [capture 3 or capture 4]"
|
||
'*(?:\'((?:\\\\.|[^\\\\\'])*)\'|"((?:\\\\.|[^\\\\"])*)"|(' + identifier + '))|)' + whitespace + '*\\]', pseudos = ':(' + identifier + ')(?:\\((' + // To reduce the number of selectors needing tokenize in the preFilter, prefer arguments:
|
||
// 1. quoted (capture 3; capture 4 or capture 5)
|
||
'(\'((?:\\\\.|[^\\\\\'])*)\'|"((?:\\\\.|[^\\\\"])*)")|' + // 2. simple (capture 6)
|
||
'((?:\\\\.|[^\\\\()[\\]]|' + attributes + ')*)|' + // 3. anything else (capture 2)
|
||
'.*' + ')\\)|)',
|
||
// Leading and non-escaped trailing whitespace, capturing some non-whitespace characters preceding the latter
|
||
rwhitespace = new RegExp(whitespace + '+', 'g'), rtrim = new RegExp('^' + whitespace + '+|((?:^|[^\\\\])(?:\\\\.)*)' + whitespace + '+$', 'g'), rcomma = new RegExp('^' + whitespace + '*,' + whitespace + '*'), rcombinators = new RegExp('^' + whitespace + '*([>+~]|' + whitespace + ')' + whitespace + '*'), rattributeQuotes = new RegExp('=' + whitespace + '*([^\\]\'"]*?)' + whitespace + '*\\]', 'g'), rpseudo = new RegExp(pseudos), ridentifier = new RegExp('^' + identifier + '$'), matchExpr = {
|
||
'ID': new RegExp('^#(' + identifier + ')'),
|
||
'CLASS': new RegExp('^\\.(' + identifier + ')'),
|
||
'TAG': new RegExp('^(' + identifier + '|[*])'),
|
||
'ATTR': new RegExp('^' + attributes),
|
||
'PSEUDO': new RegExp('^' + pseudos),
|
||
'CHILD': new RegExp('^:(only|first|last|nth|nth-last)-(child|of-type)(?:\\(' + whitespace + '*(even|odd|(([+-]|)(\\d*)n|)' + whitespace + '*(?:([+-]|)' + whitespace + '*(\\d+)|))' + whitespace + '*\\)|)', 'i'),
|
||
'bool': new RegExp('^(?:' + booleans + ')$', 'i'),
|
||
// For use in libraries implementing .is()
|
||
// We use this for POS matching in `select`
|
||
'needsContext': new RegExp('^' + whitespace + '*[>+~]|:(even|odd|eq|gt|lt|nth|first|last)(?:\\(' + whitespace + '*((?:-\\d)?\\d*)' + whitespace + '*\\)|)(?=[^-]|$)', 'i')
|
||
}, rinputs = /^(?:input|select|textarea|button)$/i, rheader = /^h\d$/i, rnative = /^[^{]+\{\s*\[native \w/,
|
||
// Easily-parseable/retrievable ID or TAG or CLASS selectors
|
||
rquickExpr = /^(?:#([\w-]+)|(\w+)|\.([\w-]+))$/, rsibling = /[+~]/, rescape = /'|\\/g,
|
||
// CSS escapes http://www.w3.org/TR/CSS21/syndata.html#escaped-characters
|
||
runescape = new RegExp('\\\\([\\da-f]{1,6}' + whitespace + '?|(' + whitespace + ')|.)', 'ig'), funescape = function (_, escaped, escapedWhitespace) {
|
||
var high = '0x' + escaped - 65536;
|
||
// NaN means non-codepoint
|
||
// Support: Firefox<24
|
||
// Workaround erroneous numeric interpretation of +"0x"
|
||
return high !== high || escapedWhitespace ? escaped : high < 0 ? // BMP codepoint
|
||
String.fromCharCode(high + 65536) : // Supplemental Plane codepoint (surrogate pair)
|
||
String.fromCharCode(high >> 10 | 55296, high & 1023 | 56320)
|
||
},
|
||
// Used for iframes
|
||
// See setDocument()
|
||
// Removing the function wrapper causes a "Permission Denied"
|
||
// error in IE
|
||
unloadHandler = function () {
|
||
setDocument()
|
||
};
|
||
// Optimize for push.apply( _, NodeList )
|
||
try {
|
||
push.apply(arr = slice.call(preferredDoc.childNodes), preferredDoc.childNodes);
|
||
// Support: Android<4.0
|
||
// Detect silently failing push.apply
|
||
arr[preferredDoc.childNodes.length].nodeType
|
||
} catch (e) {
|
||
push = {
|
||
apply: arr.length ? // Leverage slice if possible
|
||
function (target, els) {
|
||
push_native.apply(target, slice.call(els))
|
||
} : // Support: IE<9
|
||
// Otherwise append directly
|
||
function (target, els) {
|
||
var j = target.length, i = 0;
|
||
// Can't trust NodeList.length
|
||
while (target[j++] = els[i++]) {
|
||
}
|
||
target.length = j - 1
|
||
}
|
||
}
|
||
}
|
||
function Sizzle(selector, context, results, seed) {
|
||
var m, i, elem, nid, nidselect, match, groups, newSelector, newContext = context && context.ownerDocument,
|
||
// nodeType defaults to 9, since context defaults to document
|
||
nodeType = context ? context.nodeType : 9;
|
||
results = results || [];
|
||
// Return early from calls with invalid selector or context
|
||
if (typeof selector !== 'string' || !selector || nodeType !== 1 && nodeType !== 9 && nodeType !== 11) {
|
||
return results
|
||
}
|
||
// Try to shortcut find operations (as opposed to filters) in HTML documents
|
||
if (!seed) {
|
||
if ((context ? context.ownerDocument || context : preferredDoc) !== document) {
|
||
setDocument(context)
|
||
}
|
||
context = context || document;
|
||
if (documentIsHTML) {
|
||
// If the selector is sufficiently simple, try using a "get*By*" DOM method
|
||
// (excepting DocumentFragment context, where the methods don't exist)
|
||
if (nodeType !== 11 && (match = rquickExpr.exec(selector))) {
|
||
// ID selector
|
||
if (m = match[1]) {
|
||
// Document context
|
||
if (nodeType === 9) {
|
||
if (elem = context.getElementById(m)) {
|
||
// Support: IE, Opera, Webkit
|
||
// TODO: identify versions
|
||
// getElementById can match elements by name instead of ID
|
||
if (elem.id === m) {
|
||
results.push(elem);
|
||
return results
|
||
}
|
||
} else {
|
||
return results
|
||
} // Element context
|
||
} else {
|
||
// Support: IE, Opera, Webkit
|
||
// TODO: identify versions
|
||
// getElementById can match elements by name instead of ID
|
||
if (newContext && (elem = newContext.getElementById(m)) && contains(context, elem) && elem.id === m) {
|
||
results.push(elem);
|
||
return results
|
||
}
|
||
} // Type selector
|
||
} else if (match[2]) {
|
||
push.apply(results, context.getElementsByTagName(selector));
|
||
return results // Class selector
|
||
} else if ((m = match[3]) && support.getElementsByClassName && context.getElementsByClassName) {
|
||
push.apply(results, context.getElementsByClassName(m));
|
||
return results
|
||
}
|
||
}
|
||
// Take advantage of querySelectorAll
|
||
if (support.qsa && !compilerCache[selector + ' '] && (!rbuggyQSA || !rbuggyQSA.test(selector))) {
|
||
if (nodeType !== 1) {
|
||
newContext = context;
|
||
newSelector = selector // qSA looks outside Element context, which is not what we want
|
||
// Thanks to Andrew Dupont for this workaround technique
|
||
// Support: IE <=8
|
||
// Exclude object elements
|
||
} else if (context.nodeName.toLowerCase() !== 'object') {
|
||
// Capture the context ID, setting it first if necessary
|
||
if (nid = context.getAttribute('id')) {
|
||
nid = nid.replace(rescape, '\\$&')
|
||
} else {
|
||
context.setAttribute('id', nid = expando)
|
||
}
|
||
// Prefix every selector in the list
|
||
groups = tokenize(selector);
|
||
i = groups.length;
|
||
nidselect = ridentifier.test(nid) ? '#' + nid : "[id='" + nid + "']";
|
||
while (i--) {
|
||
groups[i] = nidselect + ' ' + toSelector(groups[i])
|
||
}
|
||
newSelector = groups.join(',');
|
||
// Expand context for sibling selectors
|
||
newContext = rsibling.test(selector) && testContext(context.parentNode) || context
|
||
}
|
||
if (newSelector) {
|
||
try {
|
||
push.apply(results, newContext.querySelectorAll(newSelector));
|
||
return results
|
||
} catch (qsaError) {
|
||
} finally {
|
||
if (nid === expando) {
|
||
context.removeAttribute('id')
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// All others
|
||
return select(selector.replace(rtrim, '$1'), context, results, seed)
|
||
}
|
||
/**
|
||
* Create key-value caches of limited size
|
||
* @returns {function(string, object)} Returns the Object data after storing it on itself with
|
||
* property name the (space-suffixed) string and (if the cache is larger than Expr.cacheLength)
|
||
* deleting the oldest entry
|
||
*/
|
||
function createCache() {
|
||
var keys = [];
|
||
function cache(key, value) {
|
||
// Use (key + " ") to avoid collision with native prototype properties (see Issue #157)
|
||
if (keys.push(key + ' ') > Expr.cacheLength) {
|
||
// Only keep the most recent entries
|
||
delete cache[keys.shift()]
|
||
}
|
||
return cache[key + ' '] = value
|
||
}
|
||
return cache
|
||
}
|
||
/**
|
||
* Mark a function for special use by Sizzle
|
||
* @param {Function} fn The function to mark
|
||
*/
|
||
function markFunction(fn) {
|
||
fn[expando] = true;
|
||
return fn
|
||
}
|
||
/**
|
||
* Support testing using an element
|
||
* @param {Function} fn Passed the created div and expects a boolean result
|
||
*/
|
||
function assert(fn) {
|
||
var div = document.createElement('div');
|
||
try {
|
||
return !!fn(div)
|
||
} catch (e) {
|
||
return false
|
||
} finally {
|
||
// Remove from its parent by default
|
||
if (div.parentNode) {
|
||
div.parentNode.removeChild(div)
|
||
}
|
||
// release memory in IE
|
||
div = null
|
||
}
|
||
}
|
||
/**
|
||
* Adds the same handler for all of the specified attrs
|
||
* @param {String} attrs Pipe-separated list of attributes
|
||
* @param {Function} handler The method that will be applied
|
||
*/
|
||
function addHandle(attrs, handler) {
|
||
var arr = attrs.split('|'), i = arr.length;
|
||
while (i--) {
|
||
Expr.attrHandle[arr[i]] = handler
|
||
}
|
||
}
|
||
/**
|
||
* Checks document order of two siblings
|
||
* @param {Element} a
|
||
* @param {Element} b
|
||
* @returns {Number} Returns less than 0 if a precedes b, greater than 0 if a follows b
|
||
*/
|
||
function siblingCheck(a, b) {
|
||
var cur = b && a, diff = cur && a.nodeType === 1 && b.nodeType === 1 && (~b.sourceIndex || MAX_NEGATIVE) - (~a.sourceIndex || MAX_NEGATIVE);
|
||
// Use IE sourceIndex if available on both nodes
|
||
if (diff) {
|
||
return diff
|
||
}
|
||
// Check if b follows a
|
||
if (cur) {
|
||
while (cur = cur.nextSibling) {
|
||
if (cur === b) {
|
||
return -1
|
||
}
|
||
}
|
||
}
|
||
return a ? 1 : -1
|
||
}
|
||
/**
|
||
* Returns a function to use in pseudos for input types
|
||
* @param {String} type
|
||
*/
|
||
function createInputPseudo(type) {
|
||
return function (elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return name === 'input' && elem.type === type
|
||
}
|
||
}
|
||
/**
|
||
* Returns a function to use in pseudos for buttons
|
||
* @param {String} type
|
||
*/
|
||
function createButtonPseudo(type) {
|
||
return function (elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return (name === 'input' || name === 'button') && elem.type === type
|
||
}
|
||
}
|
||
/**
|
||
* Returns a function to use in pseudos for positionals
|
||
* @param {Function} fn
|
||
*/
|
||
function createPositionalPseudo(fn) {
|
||
return markFunction(function (argument) {
|
||
argument = +argument;
|
||
return markFunction(function (seed, matches) {
|
||
var j, matchIndexes = fn([], seed.length, argument), i = matchIndexes.length;
|
||
// Match elements found at the specified indexes
|
||
while (i--) {
|
||
if (seed[j = matchIndexes[i]]) {
|
||
seed[j] = !(matches[j] = seed[j])
|
||
}
|
||
}
|
||
})
|
||
})
|
||
}
|
||
/**
|
||
* Checks a node for validity as a Sizzle context
|
||
* @param {Element|Object=} context
|
||
* @returns {Element|Object|Boolean} The input node if acceptable, otherwise a falsy value
|
||
*/
|
||
function testContext(context) {
|
||
return context && typeof context.getElementsByTagName !== 'undefined' && context
|
||
}
|
||
// Expose support vars for convenience
|
||
support = Sizzle.support = {};
|
||
/**
|
||
* Detects XML nodes
|
||
* @param {Element|Object} elem An element or a document
|
||
* @returns {Boolean} True iff elem is a non-HTML XML node
|
||
*/
|
||
isXML = Sizzle.isXML = function (elem) {
|
||
// documentElement is verified for cases where it doesn't yet exist
|
||
// (such as loading iframes in IE - #4833)
|
||
var documentElement = elem && (elem.ownerDocument || elem).documentElement;
|
||
return documentElement ? documentElement.nodeName !== 'HTML' : false
|
||
};
|
||
/**
|
||
* Sets document-related variables once based on the current document
|
||
* @param {Element|Object} [doc] An element or document object to use to set the document
|
||
* @returns {Object} Returns the current document
|
||
*/
|
||
setDocument = Sizzle.setDocument = function (node) {
|
||
var hasCompare, parent, doc = node ? node.ownerDocument || node : preferredDoc;
|
||
// Return early if doc is invalid or already selected
|
||
if (doc === document || doc.nodeType !== 9 || !doc.documentElement) {
|
||
return document
|
||
}
|
||
// Update global variables
|
||
document = doc;
|
||
docElem = document.documentElement;
|
||
documentIsHTML = !isXML(document);
|
||
// Support: IE 9-11, Edge
|
||
// Accessing iframe documents after unload throws "permission denied" errors (jQuery #13936)
|
||
if ((parent = document.defaultView) && parent.top !== parent) {
|
||
// Support: IE 11
|
||
if (parent.addEventListener) {
|
||
parent.addEventListener('unload', unloadHandler, false) // Support: IE 9 - 10 only
|
||
} else if (parent.attachEvent) {
|
||
parent.attachEvent('onunload', unloadHandler)
|
||
}
|
||
}
|
||
/* Attributes
|
||
---------------------------------------------------------------------- */
|
||
// Support: IE<8
|
||
// Verify that getAttribute really returns attributes and not properties
|
||
// (excepting IE8 booleans)
|
||
support.attributes = assert(function (div) {
|
||
div.className = 'i';
|
||
return !div.getAttribute('className')
|
||
});
|
||
/* getElement(s)By*
|
||
---------------------------------------------------------------------- */
|
||
// Check if getElementsByTagName("*") returns only elements
|
||
support.getElementsByTagName = assert(function (div) {
|
||
div.appendChild(document.createComment(''));
|
||
return !div.getElementsByTagName('*').length
|
||
});
|
||
// Support: IE<9
|
||
support.getElementsByClassName = rnative.test(document.getElementsByClassName);
|
||
// Support: IE<10
|
||
// Check if getElementById returns elements by name
|
||
// The broken getElementById methods don't pick up programatically-set names,
|
||
// so use a roundabout getElementsByName test
|
||
support.getById = assert(function (div) {
|
||
docElem.appendChild(div).id = expando;
|
||
return !document.getElementsByName || !document.getElementsByName(expando).length
|
||
});
|
||
// ID find and filter
|
||
if (support.getById) {
|
||
Expr.find['ID'] = function (id, context) {
|
||
if (typeof context.getElementById !== 'undefined' && documentIsHTML) {
|
||
var m = context.getElementById(id);
|
||
return m ? [m] : []
|
||
}
|
||
};
|
||
Expr.filter['ID'] = function (id) {
|
||
var attrId = id.replace(runescape, funescape);
|
||
return function (elem) {
|
||
return elem.getAttribute('id') === attrId
|
||
}
|
||
}
|
||
} else {
|
||
// Support: IE6/7
|
||
// getElementById is not reliable as a find shortcut
|
||
delete Expr.find['ID'];
|
||
Expr.filter['ID'] = function (id) {
|
||
var attrId = id.replace(runescape, funescape);
|
||
return function (elem) {
|
||
var node = typeof elem.getAttributeNode !== 'undefined' && elem.getAttributeNode('id');
|
||
return node && node.value === attrId
|
||
}
|
||
}
|
||
}
|
||
// Tag
|
||
Expr.find['TAG'] = support.getElementsByTagName ? function (tag, context) {
|
||
if (typeof context.getElementsByTagName !== 'undefined') {
|
||
return context.getElementsByTagName(tag) // DocumentFragment nodes don't have gEBTN
|
||
} else if (support.qsa) {
|
||
return context.querySelectorAll(tag)
|
||
}
|
||
} : function (tag, context) {
|
||
var elem, tmp = [], i = 0,
|
||
// By happy coincidence, a (broken) gEBTN appears on DocumentFragment nodes too
|
||
results = context.getElementsByTagName(tag);
|
||
// Filter out possible comments
|
||
if (tag === '*') {
|
||
while (elem = results[i++]) {
|
||
if (elem.nodeType === 1) {
|
||
tmp.push(elem)
|
||
}
|
||
}
|
||
return tmp
|
||
}
|
||
return results
|
||
};
|
||
// Class
|
||
Expr.find['CLASS'] = support.getElementsByClassName && function (className, context) {
|
||
if (typeof context.getElementsByClassName !== 'undefined' && documentIsHTML) {
|
||
return context.getElementsByClassName(className)
|
||
}
|
||
};
|
||
/* QSA/matchesSelector
|
||
---------------------------------------------------------------------- */
|
||
// QSA and matchesSelector support
|
||
// matchesSelector(:active) reports false when true (IE9/Opera 11.5)
|
||
rbuggyMatches = [];
|
||
// qSa(:focus) reports false when true (Chrome 21)
|
||
// We allow this because of a bug in IE8/9 that throws an error
|
||
// whenever `document.activeElement` is accessed on an iframe
|
||
// So, we allow :focus to pass through QSA all the time to avoid the IE error
|
||
// See http://bugs.jquery.com/ticket/13378
|
||
rbuggyQSA = [];
|
||
if (support.qsa = rnative.test(document.querySelectorAll)) {
|
||
// Build QSA regex
|
||
// Regex strategy adopted from Diego Perini
|
||
assert(function (div) {
|
||
// Select is set to empty string on purpose
|
||
// This is to test IE's treatment of not explicitly
|
||
// setting a boolean content attribute,
|
||
// since its presence should be enough
|
||
// http://bugs.jquery.com/ticket/12359
|
||
docElem.appendChild(div).innerHTML = "<a id='" + expando + "'></a>" + "<select id='" + expando + "-\r\\' msallowcapture=''>" + "<option selected=''></option></select>";
|
||
// Support: IE8, Opera 11-12.16
|
||
// Nothing should be selected when empty strings follow ^= or $= or *=
|
||
// The test attribute must be unknown in Opera but "safe" for WinRT
|
||
// http://msdn.microsoft.com/en-us/library/ie/hh465388.aspx#attribute_section
|
||
if (div.querySelectorAll("[msallowcapture^='']").length) {
|
||
rbuggyQSA.push('[*^$]=' + whitespace + '*(?:\'\'|"")')
|
||
}
|
||
// Support: IE8
|
||
// Boolean attributes and "value" are not treated correctly
|
||
if (!div.querySelectorAll('[selected]').length) {
|
||
rbuggyQSA.push('\\[' + whitespace + '*(?:value|' + booleans + ')')
|
||
}
|
||
// Support: Chrome<29, Android<4.4, Safari<7.0+, iOS<7.0+, PhantomJS<1.9.8+
|
||
if (!div.querySelectorAll('[id~=' + expando + '-]').length) {
|
||
rbuggyQSA.push('~=')
|
||
}
|
||
// Webkit/Opera - :checked should return selected option elements
|
||
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
|
||
// IE8 throws error here and will not see later tests
|
||
if (!div.querySelectorAll(':checked').length) {
|
||
rbuggyQSA.push(':checked')
|
||
}
|
||
// Support: Safari 8+, iOS 8+
|
||
// https://bugs.webkit.org/show_bug.cgi?id=136851
|
||
// In-page `selector#id sibing-combinator selector` fails
|
||
if (!div.querySelectorAll('a#' + expando + '+*').length) {
|
||
rbuggyQSA.push('.#.+[+~]')
|
||
}
|
||
});
|
||
assert(function (div) {
|
||
// Support: Windows 8 Native Apps
|
||
// The type and name attributes are restricted during .innerHTML assignment
|
||
var input = document.createElement('input');
|
||
input.setAttribute('type', 'hidden');
|
||
div.appendChild(input).setAttribute('name', 'D');
|
||
// Support: IE8
|
||
// Enforce case-sensitivity of name attribute
|
||
if (div.querySelectorAll('[name=d]').length) {
|
||
rbuggyQSA.push('name' + whitespace + '*[*^$|!~]?=')
|
||
}
|
||
// FF 3.5 - :enabled/:disabled and hidden elements (hidden elements are still enabled)
|
||
// IE8 throws error here and will not see later tests
|
||
if (!div.querySelectorAll(':enabled').length) {
|
||
rbuggyQSA.push(':enabled', ':disabled')
|
||
}
|
||
// Opera 10-11 does not throw on post-comma invalid pseudos
|
||
div.querySelectorAll('*,:x');
|
||
rbuggyQSA.push(',.*:')
|
||
})
|
||
}
|
||
if (support.matchesSelector = rnative.test(matches = docElem.matches || docElem.webkitMatchesSelector || docElem.mozMatchesSelector || docElem.oMatchesSelector || docElem.msMatchesSelector)) {
|
||
assert(function (div) {
|
||
// Check to see if it's possible to do matchesSelector
|
||
// on a disconnected node (IE 9)
|
||
support.disconnectedMatch = matches.call(div, 'div');
|
||
// This should fail with an exception
|
||
// Gecko does not error, returns false instead
|
||
matches.call(div, "[s!='']:x");
|
||
rbuggyMatches.push('!=', pseudos)
|
||
})
|
||
}
|
||
rbuggyQSA = rbuggyQSA.length && new RegExp(rbuggyQSA.join('|'));
|
||
rbuggyMatches = rbuggyMatches.length && new RegExp(rbuggyMatches.join('|'));
|
||
/* Contains
|
||
---------------------------------------------------------------------- */
|
||
hasCompare = rnative.test(docElem.compareDocumentPosition);
|
||
// Element contains another
|
||
// Purposefully self-exclusive
|
||
// As in, an element does not contain itself
|
||
contains = hasCompare || rnative.test(docElem.contains) ? function (a, b) {
|
||
var adown = a.nodeType === 9 ? a.documentElement : a, bup = b && b.parentNode;
|
||
return a === bup || !!(bup && bup.nodeType === 1 && (adown.contains ? adown.contains(bup) : a.compareDocumentPosition && a.compareDocumentPosition(bup) & 16))
|
||
} : function (a, b) {
|
||
if (b) {
|
||
while (b = b.parentNode) {
|
||
if (b === a) {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
return false
|
||
};
|
||
/* Sorting
|
||
---------------------------------------------------------------------- */
|
||
// Document order sorting
|
||
sortOrder = hasCompare ? function (a, b) {
|
||
// Flag for duplicate removal
|
||
if (a === b) {
|
||
hasDuplicate = true;
|
||
return 0
|
||
}
|
||
// Sort on method existence if only one input has compareDocumentPosition
|
||
var compare = !a.compareDocumentPosition - !b.compareDocumentPosition;
|
||
if (compare) {
|
||
return compare
|
||
}
|
||
// Calculate position if both inputs belong to the same document
|
||
compare = (a.ownerDocument || a) === (b.ownerDocument || b) ? a.compareDocumentPosition(b) : // Otherwise we know they are disconnected
|
||
1;
|
||
// Disconnected nodes
|
||
if (compare & 1 || !support.sortDetached && b.compareDocumentPosition(a) === compare) {
|
||
// Choose the first element that is related to our preferred document
|
||
if (a === document || a.ownerDocument === preferredDoc && contains(preferredDoc, a)) {
|
||
return -1
|
||
}
|
||
if (b === document || b.ownerDocument === preferredDoc && contains(preferredDoc, b)) {
|
||
return 1
|
||
}
|
||
// Maintain original order
|
||
return sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0
|
||
}
|
||
return compare & 4 ? -1 : 1
|
||
} : function (a, b) {
|
||
// Exit early if the nodes are identical
|
||
if (a === b) {
|
||
hasDuplicate = true;
|
||
return 0
|
||
}
|
||
var cur, i = 0, aup = a.parentNode, bup = b.parentNode, ap = [a], bp = [b];
|
||
// Parentless nodes are either documents or disconnected
|
||
if (!aup || !bup) {
|
||
return a === document ? -1 : b === document ? 1 : aup ? -1 : bup ? 1 : sortInput ? indexOf(sortInput, a) - indexOf(sortInput, b) : 0 // If the nodes are siblings, we can do a quick check
|
||
} else if (aup === bup) {
|
||
return siblingCheck(a, b)
|
||
}
|
||
// Otherwise we need full lists of their ancestors for comparison
|
||
cur = a;
|
||
while (cur = cur.parentNode) {
|
||
ap.unshift(cur)
|
||
}
|
||
cur = b;
|
||
while (cur = cur.parentNode) {
|
||
bp.unshift(cur)
|
||
}
|
||
// Walk down the tree looking for a discrepancy
|
||
while (ap[i] === bp[i]) {
|
||
i++
|
||
}
|
||
return i ? // Do a sibling check if the nodes have a common ancestor
|
||
siblingCheck(ap[i], bp[i]) : // Otherwise nodes in our document sort first
|
||
ap[i] === preferredDoc ? -1 : bp[i] === preferredDoc ? 1 : 0
|
||
};
|
||
return document
|
||
};
|
||
Sizzle.matches = function (expr, elements) {
|
||
return Sizzle(expr, null, null, elements)
|
||
};
|
||
Sizzle.matchesSelector = function (elem, expr) {
|
||
// Set document vars if needed
|
||
if ((elem.ownerDocument || elem) !== document) {
|
||
setDocument(elem)
|
||
}
|
||
// Make sure that attribute selectors are quoted
|
||
expr = expr.replace(rattributeQuotes, "='$1']");
|
||
if (support.matchesSelector && documentIsHTML && !compilerCache[expr + ' '] && (!rbuggyMatches || !rbuggyMatches.test(expr)) && (!rbuggyQSA || !rbuggyQSA.test(expr))) {
|
||
try {
|
||
var ret = matches.call(elem, expr);
|
||
// IE 9's matchesSelector returns false on disconnected nodes
|
||
if (ret || support.disconnectedMatch || // As well, disconnected nodes are said to be in a document
|
||
// fragment in IE 9
|
||
elem.document && elem.document.nodeType !== 11) {
|
||
return ret
|
||
}
|
||
} catch (e) {
|
||
}
|
||
}
|
||
return Sizzle(expr, document, null, [elem]).length > 0
|
||
};
|
||
Sizzle.contains = function (context, elem) {
|
||
// Set document vars if needed
|
||
if ((context.ownerDocument || context) !== document) {
|
||
setDocument(context)
|
||
}
|
||
return contains(context, elem)
|
||
};
|
||
Sizzle.attr = function (elem, name) {
|
||
// Set document vars if needed
|
||
if ((elem.ownerDocument || elem) !== document) {
|
||
setDocument(elem)
|
||
}
|
||
var fn = Expr.attrHandle[name.toLowerCase()],
|
||
// Don't get fooled by Object.prototype properties (jQuery #13807)
|
||
val = fn && hasOwn.call(Expr.attrHandle, name.toLowerCase()) ? fn(elem, name, !documentIsHTML) : undefined;
|
||
return val !== undefined ? val : support.attributes || !documentIsHTML ? elem.getAttribute(name) : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null
|
||
};
|
||
Sizzle.error = function (msg) {
|
||
throw new Error('Syntax error, unrecognized expression: ' + msg)
|
||
};
|
||
/**
|
||
* Document sorting and removing duplicates
|
||
* @param {ArrayLike} results
|
||
*/
|
||
Sizzle.uniqueSort = function (results) {
|
||
var elem, duplicates = [], j = 0, i = 0;
|
||
// Unless we *know* we can detect duplicates, assume their presence
|
||
hasDuplicate = !support.detectDuplicates;
|
||
sortInput = !support.sortStable && results.slice(0);
|
||
results.sort(sortOrder);
|
||
if (hasDuplicate) {
|
||
while (elem = results[i++]) {
|
||
if (elem === results[i]) {
|
||
j = duplicates.push(i)
|
||
}
|
||
}
|
||
while (j--) {
|
||
results.splice(duplicates[j], 1)
|
||
}
|
||
}
|
||
// Clear input after sorting to release objects
|
||
// See https://github.com/jquery/sizzle/pull/225
|
||
sortInput = null;
|
||
return results
|
||
};
|
||
/**
|
||
* Utility function for retrieving the text value of an array of DOM nodes
|
||
* @param {Array|Element} elem
|
||
*/
|
||
getText = Sizzle.getText = function (elem) {
|
||
var node, ret = '', i = 0, nodeType = elem.nodeType;
|
||
if (!nodeType) {
|
||
// If no nodeType, this is expected to be an array
|
||
while (node = elem[i++]) {
|
||
// Do not traverse comment nodes
|
||
ret += getText(node)
|
||
}
|
||
} else if (nodeType === 1 || nodeType === 9 || nodeType === 11) {
|
||
// Use textContent for elements
|
||
// innerText usage removed for consistency of new lines (jQuery #11153)
|
||
if (typeof elem.textContent === 'string') {
|
||
return elem.textContent
|
||
} else {
|
||
// Traverse its children
|
||
for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
|
||
ret += getText(elem)
|
||
}
|
||
}
|
||
} else if (nodeType === 3 || nodeType === 4) {
|
||
return elem.nodeValue
|
||
}
|
||
// Do not include comment or processing instruction nodes
|
||
return ret
|
||
};
|
||
Expr = Sizzle.selectors = {
|
||
// Can be adjusted by the user
|
||
cacheLength: 50,
|
||
createPseudo: markFunction,
|
||
match: matchExpr,
|
||
attrHandle: {},
|
||
find: {},
|
||
relative: {
|
||
'>': {
|
||
dir: 'parentNode',
|
||
first: true
|
||
},
|
||
' ': { dir: 'parentNode' },
|
||
'+': {
|
||
dir: 'previousSibling',
|
||
first: true
|
||
},
|
||
'~': { dir: 'previousSibling' }
|
||
},
|
||
preFilter: {
|
||
'ATTR': function (match) {
|
||
match[1] = match[1].replace(runescape, funescape);
|
||
// Move the given value to match[3] whether quoted or unquoted
|
||
match[3] = (match[3] || match[4] || match[5] || '').replace(runescape, funescape);
|
||
if (match[2] === '~=') {
|
||
match[3] = ' ' + match[3] + ' '
|
||
}
|
||
return match.slice(0, 4)
|
||
},
|
||
'CHILD': function (match) {
|
||
/* matches from matchExpr["CHILD"]
|
||
1 type (only|nth|...)
|
||
2 what (child|of-type)
|
||
3 argument (even|odd|\d*|\d*n([+-]\d+)?|...)
|
||
4 xn-component of xn+y argument ([+-]?\d*n|)
|
||
5 sign of xn-component
|
||
6 x of xn-component
|
||
7 sign of y-component
|
||
8 y of y-component
|
||
*/
|
||
match[1] = match[1].toLowerCase();
|
||
if (match[1].slice(0, 3) === 'nth') {
|
||
// nth-* requires argument
|
||
if (!match[3]) {
|
||
Sizzle.error(match[0])
|
||
}
|
||
// numeric x and y parameters for Expr.filter.CHILD
|
||
// remember that false/true cast respectively to 0/1
|
||
match[4] = +(match[4] ? match[5] + (match[6] || 1) : 2 * (match[3] === 'even' || match[3] === 'odd'));
|
||
match[5] = +(match[7] + match[8] || match[3] === 'odd') // other types prohibit arguments
|
||
} else if (match[3]) {
|
||
Sizzle.error(match[0])
|
||
}
|
||
return match
|
||
},
|
||
'PSEUDO': function (match) {
|
||
var excess, unquoted = !match[6] && match[2];
|
||
if (matchExpr['CHILD'].test(match[0])) {
|
||
return null
|
||
}
|
||
// Accept quoted arguments as-is
|
||
if (match[3]) {
|
||
match[2] = match[4] || match[5] || '' // Strip excess characters from unquoted arguments
|
||
} else if (unquoted && rpseudo.test(unquoted) && (excess = tokenize(unquoted, true)) && (excess = unquoted.indexOf(')', unquoted.length - excess) - unquoted.length)) {
|
||
// excess is a negative index
|
||
match[0] = match[0].slice(0, excess);
|
||
match[2] = unquoted.slice(0, excess)
|
||
}
|
||
// Return only captures needed by the pseudo filter method (type and argument)
|
||
return match.slice(0, 3)
|
||
}
|
||
},
|
||
filter: {
|
||
'TAG': function (nodeNameSelector) {
|
||
var nodeName = nodeNameSelector.replace(runescape, funescape).toLowerCase();
|
||
return nodeNameSelector === '*' ? function () {
|
||
return true
|
||
} : function (elem) {
|
||
return elem.nodeName && elem.nodeName.toLowerCase() === nodeName
|
||
}
|
||
},
|
||
'CLASS': function (className) {
|
||
var pattern = classCache[className + ' '];
|
||
return pattern || (pattern = new RegExp('(^|' + whitespace + ')' + className + '(' + whitespace + '|$)')) && classCache(className, function (elem) {
|
||
return pattern.test(typeof elem.className === 'string' && elem.className || typeof elem.getAttribute !== 'undefined' && elem.getAttribute('class') || '')
|
||
})
|
||
},
|
||
'ATTR': function (name, operator, check) {
|
||
return function (elem) {
|
||
var result = Sizzle.attr(elem, name);
|
||
if (result == null) {
|
||
return operator === '!='
|
||
}
|
||
if (!operator) {
|
||
return true
|
||
}
|
||
result += '';
|
||
return operator === '=' ? result === check : operator === '!=' ? result !== check : operator === '^=' ? check && result.indexOf(check) === 0 : operator === '*=' ? check && result.indexOf(check) > -1 : operator === '$=' ? check && result.slice(-check.length) === check : operator === '~=' ? (' ' + result.replace(rwhitespace, ' ') + ' ').indexOf(check) > -1 : operator === '|=' ? result === check || result.slice(0, check.length + 1) === check + '-' : false
|
||
}
|
||
},
|
||
'CHILD': function (type, what, argument, first, last) {
|
||
var simple = type.slice(0, 3) !== 'nth', forward = type.slice(-4) !== 'last', ofType = what === 'of-type';
|
||
return first === 1 && last === 0 ? // Shortcut for :nth-*(n)
|
||
function (elem) {
|
||
return !!elem.parentNode
|
||
} : function (elem, context, xml) {
|
||
var cache, uniqueCache, outerCache, node, nodeIndex, start, dir = simple !== forward ? 'nextSibling' : 'previousSibling', parent = elem.parentNode, name = ofType && elem.nodeName.toLowerCase(), useCache = !xml && !ofType, diff = false;
|
||
if (parent) {
|
||
// :(first|last|only)-(child|of-type)
|
||
if (simple) {
|
||
while (dir) {
|
||
node = elem;
|
||
while (node = node[dir]) {
|
||
if (ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) {
|
||
return false
|
||
}
|
||
}
|
||
// Reverse direction for :only-* (if we haven't yet done so)
|
||
start = dir = type === 'only' && !start && 'nextSibling'
|
||
}
|
||
return true
|
||
}
|
||
start = [forward ? parent.firstChild : parent.lastChild];
|
||
// non-xml :nth-child(...) stores cache data on `parent`
|
||
if (forward && useCache) {
|
||
// Seek `elem` from a previously-cached index
|
||
// ...in a gzip-friendly way
|
||
node = parent;
|
||
outerCache = node[expando] || (node[expando] = {});
|
||
// Support: IE <9 only
|
||
// Defend against cloned attroperties (jQuery gh-1709)
|
||
uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
|
||
cache = uniqueCache[type] || [];
|
||
nodeIndex = cache[0] === dirruns && cache[1];
|
||
diff = nodeIndex && cache[2];
|
||
node = nodeIndex && parent.childNodes[nodeIndex];
|
||
while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
|
||
// When found, cache indexes on `parent` and break
|
||
if (node.nodeType === 1 && ++diff && node === elem) {
|
||
uniqueCache[type] = [
|
||
dirruns,
|
||
nodeIndex,
|
||
diff
|
||
];
|
||
break
|
||
}
|
||
}
|
||
} else {
|
||
// Use previously-cached element index if available
|
||
if (useCache) {
|
||
// ...in a gzip-friendly way
|
||
node = elem;
|
||
outerCache = node[expando] || (node[expando] = {});
|
||
// Support: IE <9 only
|
||
// Defend against cloned attroperties (jQuery gh-1709)
|
||
uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
|
||
cache = uniqueCache[type] || [];
|
||
nodeIndex = cache[0] === dirruns && cache[1];
|
||
diff = nodeIndex
|
||
}
|
||
// xml :nth-child(...)
|
||
// or :nth-last-child(...) or :nth(-last)?-of-type(...)
|
||
if (diff === false) {
|
||
// Use the same loop as above to seek `elem` from the start
|
||
while (node = ++nodeIndex && node && node[dir] || (diff = nodeIndex = 0) || start.pop()) {
|
||
if ((ofType ? node.nodeName.toLowerCase() === name : node.nodeType === 1) && ++diff) {
|
||
// Cache the index of each encountered element
|
||
if (useCache) {
|
||
outerCache = node[expando] || (node[expando] = {});
|
||
// Support: IE <9 only
|
||
// Defend against cloned attroperties (jQuery gh-1709)
|
||
uniqueCache = outerCache[node.uniqueID] || (outerCache[node.uniqueID] = {});
|
||
uniqueCache[type] = [
|
||
dirruns,
|
||
diff
|
||
]
|
||
}
|
||
if (node === elem) {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Incorporate the offset, then check against cycle size
|
||
diff -= last;
|
||
return diff === first || diff % first === 0 && diff / first >= 0
|
||
}
|
||
}
|
||
},
|
||
'PSEUDO': function (pseudo, argument) {
|
||
// pseudo-class names are case-insensitive
|
||
// http://www.w3.org/TR/selectors/#pseudo-classes
|
||
// Prioritize by case sensitivity in case custom pseudos are added with uppercase letters
|
||
// Remember that setFilters inherits from pseudos
|
||
var args, fn = Expr.pseudos[pseudo] || Expr.setFilters[pseudo.toLowerCase()] || Sizzle.error('unsupported pseudo: ' + pseudo);
|
||
// The user may use createPseudo to indicate that
|
||
// arguments are needed to create the filter function
|
||
// just as Sizzle does
|
||
if (fn[expando]) {
|
||
return fn(argument)
|
||
}
|
||
// But maintain support for old signatures
|
||
if (fn.length > 1) {
|
||
args = [
|
||
pseudo,
|
||
pseudo,
|
||
'',
|
||
argument
|
||
];
|
||
return Expr.setFilters.hasOwnProperty(pseudo.toLowerCase()) ? markFunction(function (seed, matches) {
|
||
var idx, matched = fn(seed, argument), i = matched.length;
|
||
while (i--) {
|
||
idx = indexOf(seed, matched[i]);
|
||
seed[idx] = !(matches[idx] = matched[i])
|
||
}
|
||
}) : function (elem) {
|
||
return fn(elem, 0, args)
|
||
}
|
||
}
|
||
return fn
|
||
}
|
||
},
|
||
pseudos: {
|
||
// Potentially complex pseudos
|
||
'not': markFunction(function (selector) {
|
||
// Trim the selector passed to compile
|
||
// to avoid treating leading and trailing
|
||
// spaces as combinators
|
||
var input = [], results = [], matcher = compile(selector.replace(rtrim, '$1'));
|
||
return matcher[expando] ? markFunction(function (seed, matches, context, xml) {
|
||
var elem, unmatched = matcher(seed, null, xml, []), i = seed.length;
|
||
// Match elements unmatched by `matcher`
|
||
while (i--) {
|
||
if (elem = unmatched[i]) {
|
||
seed[i] = !(matches[i] = elem)
|
||
}
|
||
}
|
||
}) : function (elem, context, xml) {
|
||
input[0] = elem;
|
||
matcher(input, null, xml, results);
|
||
// Don't keep the element (issue #299)
|
||
input[0] = null;
|
||
return !results.pop()
|
||
}
|
||
}),
|
||
'has': markFunction(function (selector) {
|
||
return function (elem) {
|
||
return Sizzle(selector, elem).length > 0
|
||
}
|
||
}),
|
||
'contains': markFunction(function (text) {
|
||
text = text.replace(runescape, funescape);
|
||
return function (elem) {
|
||
return (elem.textContent || elem.innerText || getText(elem)).indexOf(text) > -1
|
||
}
|
||
}),
|
||
// "Whether an element is represented by a :lang() selector
|
||
// is based solely on the element's language value
|
||
// being equal to the identifier C,
|
||
// or beginning with the identifier C immediately followed by "-".
|
||
// The matching of C against the element's language value is performed case-insensitively.
|
||
// The identifier C does not have to be a valid language name."
|
||
// http://www.w3.org/TR/selectors/#lang-pseudo
|
||
'lang': markFunction(function (lang) {
|
||
// lang value must be a valid identifier
|
||
if (!ridentifier.test(lang || '')) {
|
||
Sizzle.error('unsupported lang: ' + lang)
|
||
}
|
||
lang = lang.replace(runescape, funescape).toLowerCase();
|
||
return function (elem) {
|
||
var elemLang;
|
||
do {
|
||
if (elemLang = documentIsHTML ? elem.lang : elem.getAttribute('xml:lang') || elem.getAttribute('lang')) {
|
||
elemLang = elemLang.toLowerCase();
|
||
return elemLang === lang || elemLang.indexOf(lang + '-') === 0
|
||
}
|
||
} while ((elem = elem.parentNode) && elem.nodeType === 1);
|
||
return false
|
||
}
|
||
}),
|
||
// Miscellaneous
|
||
'target': function (elem) {
|
||
var hash = window.location && window.location.hash;
|
||
return hash && hash.slice(1) === elem.id
|
||
},
|
||
'root': function (elem) {
|
||
return elem === docElem
|
||
},
|
||
'focus': function (elem) {
|
||
return elem === document.activeElement && (!document.hasFocus || document.hasFocus()) && !!(elem.type || elem.href || ~elem.tabIndex)
|
||
},
|
||
// Boolean properties
|
||
'enabled': function (elem) {
|
||
return elem.disabled === false
|
||
},
|
||
'disabled': function (elem) {
|
||
return elem.disabled === true
|
||
},
|
||
'checked': function (elem) {
|
||
// In CSS3, :checked should return both checked and selected elements
|
||
// http://www.w3.org/TR/2011/REC-css3-selectors-20110929/#checked
|
||
var nodeName = elem.nodeName.toLowerCase();
|
||
return nodeName === 'input' && !!elem.checked || nodeName === 'option' && !!elem.selected
|
||
},
|
||
'selected': function (elem) {
|
||
// Accessing this property makes selected-by-default
|
||
// options in Safari work properly
|
||
if (elem.parentNode) {
|
||
elem.parentNode.selectedIndex
|
||
}
|
||
return elem.selected === true
|
||
},
|
||
// Contents
|
||
'empty': function (elem) {
|
||
// http://www.w3.org/TR/selectors/#empty-pseudo
|
||
// :empty is negated by element (1) or content nodes (text: 3; cdata: 4; entity ref: 5),
|
||
// but not by others (comment: 8; processing instruction: 7; etc.)
|
||
// nodeType < 6 works because attributes (2) do not appear as children
|
||
for (elem = elem.firstChild; elem; elem = elem.nextSibling) {
|
||
if (elem.nodeType < 6) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
},
|
||
'parent': function (elem) {
|
||
return !Expr.pseudos['empty'](elem)
|
||
},
|
||
// Element/input types
|
||
'header': function (elem) {
|
||
return rheader.test(elem.nodeName)
|
||
},
|
||
'input': function (elem) {
|
||
return rinputs.test(elem.nodeName)
|
||
},
|
||
'button': function (elem) {
|
||
var name = elem.nodeName.toLowerCase();
|
||
return name === 'input' && elem.type === 'button' || name === 'button'
|
||
},
|
||
'text': function (elem) {
|
||
var attr;
|
||
return elem.nodeName.toLowerCase() === 'input' && elem.type === 'text' && ((attr = elem.getAttribute('type')) == null || attr.toLowerCase() === 'text')
|
||
},
|
||
// Position-in-collection
|
||
'first': createPositionalPseudo(function () {
|
||
return [0]
|
||
}),
|
||
'last': createPositionalPseudo(function (matchIndexes, length) {
|
||
return [length - 1]
|
||
}),
|
||
'eq': createPositionalPseudo(function (matchIndexes, length, argument) {
|
||
return [argument < 0 ? argument + length : argument]
|
||
}),
|
||
'even': createPositionalPseudo(function (matchIndexes, length) {
|
||
var i = 0;
|
||
for (; i < length; i += 2) {
|
||
matchIndexes.push(i)
|
||
}
|
||
return matchIndexes
|
||
}),
|
||
'odd': createPositionalPseudo(function (matchIndexes, length) {
|
||
var i = 1;
|
||
for (; i < length; i += 2) {
|
||
matchIndexes.push(i)
|
||
}
|
||
return matchIndexes
|
||
}),
|
||
'lt': createPositionalPseudo(function (matchIndexes, length, argument) {
|
||
var i = argument < 0 ? argument + length : argument;
|
||
for (; --i >= 0;) {
|
||
matchIndexes.push(i)
|
||
}
|
||
return matchIndexes
|
||
}),
|
||
'gt': createPositionalPseudo(function (matchIndexes, length, argument) {
|
||
var i = argument < 0 ? argument + length : argument;
|
||
for (; ++i < length;) {
|
||
matchIndexes.push(i)
|
||
}
|
||
return matchIndexes
|
||
})
|
||
}
|
||
};
|
||
Expr.pseudos['nth'] = Expr.pseudos['eq'];
|
||
// Add button/input type pseudos
|
||
for (i in {
|
||
radio: true,
|
||
checkbox: true,
|
||
file: true,
|
||
password: true,
|
||
image: true
|
||
}) {
|
||
Expr.pseudos[i] = createInputPseudo(i)
|
||
}
|
||
for (i in {
|
||
submit: true,
|
||
reset: true
|
||
}) {
|
||
Expr.pseudos[i] = createButtonPseudo(i)
|
||
}
|
||
// Easy API for creating new setFilters
|
||
function setFilters() {
|
||
}
|
||
setFilters.prototype = Expr.filters = Expr.pseudos;
|
||
Expr.setFilters = new setFilters;
|
||
tokenize = Sizzle.tokenize = function (selector, parseOnly) {
|
||
var matched, match, tokens, type, soFar, groups, preFilters, cached = tokenCache[selector + ' '];
|
||
if (cached) {
|
||
return parseOnly ? 0 : cached.slice(0)
|
||
}
|
||
soFar = selector;
|
||
groups = [];
|
||
preFilters = Expr.preFilter;
|
||
while (soFar) {
|
||
// Comma and first run
|
||
if (!matched || (match = rcomma.exec(soFar))) {
|
||
if (match) {
|
||
// Don't consume trailing commas as valid
|
||
soFar = soFar.slice(match[0].length) || soFar
|
||
}
|
||
groups.push(tokens = [])
|
||
}
|
||
matched = false;
|
||
// Combinators
|
||
if (match = rcombinators.exec(soFar)) {
|
||
matched = match.shift();
|
||
tokens.push({
|
||
value: matched,
|
||
// Cast descendant combinators to space
|
||
type: match[0].replace(rtrim, ' ')
|
||
});
|
||
soFar = soFar.slice(matched.length)
|
||
}
|
||
// Filters
|
||
for (type in Expr.filter) {
|
||
if ((match = matchExpr[type].exec(soFar)) && (!preFilters[type] || (match = preFilters[type](match)))) {
|
||
matched = match.shift();
|
||
tokens.push({
|
||
value: matched,
|
||
type: type,
|
||
matches: match
|
||
});
|
||
soFar = soFar.slice(matched.length)
|
||
}
|
||
}
|
||
if (!matched) {
|
||
break
|
||
}
|
||
}
|
||
// Return the length of the invalid excess
|
||
// if we're just parsing
|
||
// Otherwise, throw an error or return tokens
|
||
return parseOnly ? soFar.length : soFar ? Sizzle.error(selector) : // Cache the tokens
|
||
tokenCache(selector, groups).slice(0)
|
||
};
|
||
function toSelector(tokens) {
|
||
var i = 0, len = tokens.length, selector = '';
|
||
for (; i < len; i++) {
|
||
selector += tokens[i].value
|
||
}
|
||
return selector
|
||
}
|
||
function addCombinator(matcher, combinator, base) {
|
||
var dir = combinator.dir, checkNonElements = base && dir === 'parentNode', doneName = done++;
|
||
return combinator.first ? // Check against closest ancestor/preceding element
|
||
function (elem, context, xml) {
|
||
while (elem = elem[dir]) {
|
||
if (elem.nodeType === 1 || checkNonElements) {
|
||
return matcher(elem, context, xml)
|
||
}
|
||
}
|
||
} : // Check against all ancestor/preceding elements
|
||
function (elem, context, xml) {
|
||
var oldCache, uniqueCache, outerCache, newCache = [
|
||
dirruns,
|
||
doneName
|
||
];
|
||
// We can't set arbitrary data on XML nodes, so they don't benefit from combinator caching
|
||
if (xml) {
|
||
while (elem = elem[dir]) {
|
||
if (elem.nodeType === 1 || checkNonElements) {
|
||
if (matcher(elem, context, xml)) {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
while (elem = elem[dir]) {
|
||
if (elem.nodeType === 1 || checkNonElements) {
|
||
outerCache = elem[expando] || (elem[expando] = {});
|
||
// Support: IE <9 only
|
||
// Defend against cloned attroperties (jQuery gh-1709)
|
||
uniqueCache = outerCache[elem.uniqueID] || (outerCache[elem.uniqueID] = {});
|
||
if ((oldCache = uniqueCache[dir]) && oldCache[0] === dirruns && oldCache[1] === doneName) {
|
||
// Assign to newCache so results back-propagate to previous elements
|
||
return newCache[2] = oldCache[2]
|
||
} else {
|
||
// Reuse newcache so results back-propagate to previous elements
|
||
uniqueCache[dir] = newCache;
|
||
// A match means we're done; a fail means we have to keep checking
|
||
if (newCache[2] = matcher(elem, context, xml)) {
|
||
return true
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
function elementMatcher(matchers) {
|
||
return matchers.length > 1 ? function (elem, context, xml) {
|
||
var i = matchers.length;
|
||
while (i--) {
|
||
if (!matchers[i](elem, context, xml)) {
|
||
return false
|
||
}
|
||
}
|
||
return true
|
||
} : matchers[0]
|
||
}
|
||
function multipleContexts(selector, contexts, results) {
|
||
var i = 0, len = contexts.length;
|
||
for (; i < len; i++) {
|
||
Sizzle(selector, contexts[i], results)
|
||
}
|
||
return results
|
||
}
|
||
function condense(unmatched, map, filter, context, xml) {
|
||
var elem, newUnmatched = [], i = 0, len = unmatched.length, mapped = map != null;
|
||
for (; i < len; i++) {
|
||
if (elem = unmatched[i]) {
|
||
if (!filter || filter(elem, context, xml)) {
|
||
newUnmatched.push(elem);
|
||
if (mapped) {
|
||
map.push(i)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return newUnmatched
|
||
}
|
||
function setMatcher(preFilter, selector, matcher, postFilter, postFinder, postSelector) {
|
||
if (postFilter && !postFilter[expando]) {
|
||
postFilter = setMatcher(postFilter)
|
||
}
|
||
if (postFinder && !postFinder[expando]) {
|
||
postFinder = setMatcher(postFinder, postSelector)
|
||
}
|
||
return markFunction(function (seed, results, context, xml) {
|
||
var temp, i, elem, preMap = [], postMap = [], preexisting = results.length,
|
||
// Get initial elements from seed or context
|
||
elems = seed || multipleContexts(selector || '*', context.nodeType ? [context] : context, []),
|
||
// Prefilter to get matcher input, preserving a map for seed-results synchronization
|
||
matcherIn = preFilter && (seed || !selector) ? condense(elems, preMap, preFilter, context, xml) : elems, matcherOut = matcher ? // If we have a postFinder, or filtered seed, or non-seed postFilter or preexisting results,
|
||
postFinder || (seed ? preFilter : preexisting || postFilter) ? // ...intermediate processing is necessary
|
||
[] : // ...otherwise use results directly
|
||
results : matcherIn;
|
||
// Find primary matches
|
||
if (matcher) {
|
||
matcher(matcherIn, matcherOut, context, xml)
|
||
}
|
||
// Apply postFilter
|
||
if (postFilter) {
|
||
temp = condense(matcherOut, postMap);
|
||
postFilter(temp, [], context, xml);
|
||
// Un-match failing elements by moving them back to matcherIn
|
||
i = temp.length;
|
||
while (i--) {
|
||
if (elem = temp[i]) {
|
||
matcherOut[postMap[i]] = !(matcherIn[postMap[i]] = elem)
|
||
}
|
||
}
|
||
}
|
||
if (seed) {
|
||
if (postFinder || preFilter) {
|
||
if (postFinder) {
|
||
// Get the final matcherOut by condensing this intermediate into postFinder contexts
|
||
temp = [];
|
||
i = matcherOut.length;
|
||
while (i--) {
|
||
if (elem = matcherOut[i]) {
|
||
// Restore matcherIn since elem is not yet a final match
|
||
temp.push(matcherIn[i] = elem)
|
||
}
|
||
}
|
||
postFinder(null, matcherOut = [], temp, xml)
|
||
}
|
||
// Move matched elements from seed to results to keep them synchronized
|
||
i = matcherOut.length;
|
||
while (i--) {
|
||
if ((elem = matcherOut[i]) && (temp = postFinder ? indexOf(seed, elem) : preMap[i]) > -1) {
|
||
seed[temp] = !(results[temp] = elem)
|
||
}
|
||
}
|
||
} // Add elements to results, through postFinder if defined
|
||
} else {
|
||
matcherOut = condense(matcherOut === results ? matcherOut.splice(preexisting, matcherOut.length) : matcherOut);
|
||
if (postFinder) {
|
||
postFinder(null, results, matcherOut, xml)
|
||
} else {
|
||
push.apply(results, matcherOut)
|
||
}
|
||
}
|
||
})
|
||
}
|
||
function matcherFromTokens(tokens) {
|
||
var checkContext, matcher, j, len = tokens.length, leadingRelative = Expr.relative[tokens[0].type], implicitRelative = leadingRelative || Expr.relative[' '], i = leadingRelative ? 1 : 0,
|
||
// The foundational matcher ensures that elements are reachable from top-level context(s)
|
||
matchContext = addCombinator(function (elem) {
|
||
return elem === checkContext
|
||
}, implicitRelative, true), matchAnyContext = addCombinator(function (elem) {
|
||
return indexOf(checkContext, elem) > -1
|
||
}, implicitRelative, true), matchers = [function (elem, context, xml) {
|
||
var ret = !leadingRelative && (xml || context !== outermostContext) || ((checkContext = context).nodeType ? matchContext(elem, context, xml) : matchAnyContext(elem, context, xml));
|
||
// Avoid hanging onto element (issue #299)
|
||
checkContext = null;
|
||
return ret
|
||
}];
|
||
for (; i < len; i++) {
|
||
if (matcher = Expr.relative[tokens[i].type]) {
|
||
matchers = [addCombinator(elementMatcher(matchers), matcher)]
|
||
} else {
|
||
matcher = Expr.filter[tokens[i].type].apply(null, tokens[i].matches);
|
||
// Return special upon seeing a positional matcher
|
||
if (matcher[expando]) {
|
||
// Find the next relative operator (if any) for proper handling
|
||
j = ++i;
|
||
for (; j < len; j++) {
|
||
if (Expr.relative[tokens[j].type]) {
|
||
break
|
||
}
|
||
}
|
||
return setMatcher(i > 1 && elementMatcher(matchers), i > 1 && toSelector(// If the preceding token was a descendant combinator, insert an implicit any-element `*`
|
||
tokens.slice(0, i - 1).concat({ value: tokens[i - 2].type === ' ' ? '*' : '' })).replace(rtrim, '$1'), matcher, i < j && matcherFromTokens(tokens.slice(i, j)), j < len && matcherFromTokens(tokens = tokens.slice(j)), j < len && toSelector(tokens))
|
||
}
|
||
matchers.push(matcher)
|
||
}
|
||
}
|
||
return elementMatcher(matchers)
|
||
}
|
||
function matcherFromGroupMatchers(elementMatchers, setMatchers) {
|
||
var bySet = setMatchers.length > 0, byElement = elementMatchers.length > 0, superMatcher = function (seed, context, xml, results, outermost) {
|
||
var elem, j, matcher, matchedCount = 0, i = '0', unmatched = seed && [], setMatched = [], contextBackup = outermostContext,
|
||
// We must always have either seed elements or outermost context
|
||
elems = seed || byElement && Expr.find['TAG']('*', outermost),
|
||
// Use integer dirruns iff this is the outermost matcher
|
||
dirrunsUnique = dirruns += contextBackup == null ? 1 : Math.random() || 0.1, len = elems.length;
|
||
if (outermost) {
|
||
outermostContext = context === document || context || outermost
|
||
}
|
||
// Add elements passing elementMatchers directly to results
|
||
// Support: IE<9, Safari
|
||
// Tolerate NodeList properties (IE: "length"; Safari: <number>) matching elements by id
|
||
for (; i !== len && (elem = elems[i]) != null; i++) {
|
||
if (byElement && elem) {
|
||
j = 0;
|
||
if (!context && elem.ownerDocument !== document) {
|
||
setDocument(elem);
|
||
xml = !documentIsHTML
|
||
}
|
||
while (matcher = elementMatchers[j++]) {
|
||
if (matcher(elem, context || document, xml)) {
|
||
results.push(elem);
|
||
break
|
||
}
|
||
}
|
||
if (outermost) {
|
||
dirruns = dirrunsUnique
|
||
}
|
||
}
|
||
// Track unmatched elements for set filters
|
||
if (bySet) {
|
||
// They will have gone through all possible matchers
|
||
if (elem = !matcher && elem) {
|
||
matchedCount--
|
||
}
|
||
// Lengthen the array for every element, matched or not
|
||
if (seed) {
|
||
unmatched.push(elem)
|
||
}
|
||
}
|
||
}
|
||
// `i` is now the count of elements visited above, and adding it to `matchedCount`
|
||
// makes the latter nonnegative.
|
||
matchedCount += i;
|
||
// Apply set filters to unmatched elements
|
||
// NOTE: This can be skipped if there are no unmatched elements (i.e., `matchedCount`
|
||
// equals `i`), unless we didn't visit _any_ elements in the above loop because we have
|
||
// no element matchers and no seed.
|
||
// Incrementing an initially-string "0" `i` allows `i` to remain a string only in that
|
||
// case, which will result in a "00" `matchedCount` that differs from `i` but is also
|
||
// numerically zero.
|
||
if (bySet && i !== matchedCount) {
|
||
j = 0;
|
||
while (matcher = setMatchers[j++]) {
|
||
matcher(unmatched, setMatched, context, xml)
|
||
}
|
||
if (seed) {
|
||
// Reintegrate element matches to eliminate the need for sorting
|
||
if (matchedCount > 0) {
|
||
while (i--) {
|
||
if (!(unmatched[i] || setMatched[i])) {
|
||
setMatched[i] = pop.call(results)
|
||
}
|
||
}
|
||
}
|
||
// Discard index placeholder values to get only actual matches
|
||
setMatched = condense(setMatched)
|
||
}
|
||
// Add matches to results
|
||
push.apply(results, setMatched);
|
||
// Seedless set matches succeeding multiple successful matchers stipulate sorting
|
||
if (outermost && !seed && setMatched.length > 0 && matchedCount + setMatchers.length > 1) {
|
||
Sizzle.uniqueSort(results)
|
||
}
|
||
}
|
||
// Override manipulation of globals by nested matchers
|
||
if (outermost) {
|
||
dirruns = dirrunsUnique;
|
||
outermostContext = contextBackup
|
||
}
|
||
return unmatched
|
||
};
|
||
return bySet ? markFunction(superMatcher) : superMatcher
|
||
}
|
||
compile = Sizzle.compile = function (selector, match) {
|
||
var i, setMatchers = [], elementMatchers = [], cached = compilerCache[selector + ' '];
|
||
if (!cached) {
|
||
// Generate a function of recursive functions that can be used to check each element
|
||
if (!match) {
|
||
match = tokenize(selector)
|
||
}
|
||
i = match.length;
|
||
while (i--) {
|
||
cached = matcherFromTokens(match[i]);
|
||
if (cached[expando]) {
|
||
setMatchers.push(cached)
|
||
} else {
|
||
elementMatchers.push(cached)
|
||
}
|
||
}
|
||
// Cache the compiled function
|
||
cached = compilerCache(selector, matcherFromGroupMatchers(elementMatchers, setMatchers));
|
||
// Save selector and tokenization
|
||
cached.selector = selector
|
||
}
|
||
return cached
|
||
};
|
||
/**
|
||
* A low-level selection function that works with Sizzle's compiled
|
||
* selector functions
|
||
* @param {String|Function} selector A selector or a pre-compiled
|
||
* selector function built with Sizzle.compile
|
||
* @param {Element} context
|
||
* @param {Array} [results]
|
||
* @param {Array} [seed] A set of elements to match against
|
||
*/
|
||
select = Sizzle.select = function (selector, context, results, seed) {
|
||
var i, tokens, token, type, find, compiled = typeof selector === 'function' && selector, match = !seed && tokenize(selector = compiled.selector || selector);
|
||
results = results || [];
|
||
// Try to minimize operations if there is only one selector in the list and no seed
|
||
// (the latter of which guarantees us context)
|
||
if (match.length === 1) {
|
||
// Reduce context if the leading compound selector is an ID
|
||
tokens = match[0] = match[0].slice(0);
|
||
if (tokens.length > 2 && (token = tokens[0]).type === 'ID' && support.getById && context.nodeType === 9 && documentIsHTML && Expr.relative[tokens[1].type]) {
|
||
context = (Expr.find['ID'](token.matches[0].replace(runescape, funescape), context) || [])[0];
|
||
if (!context) {
|
||
return results // Precompiled matchers will still verify ancestry, so step up a level
|
||
} else if (compiled) {
|
||
context = context.parentNode
|
||
}
|
||
selector = selector.slice(tokens.shift().value.length)
|
||
}
|
||
// Fetch a seed set for right-to-left matching
|
||
i = matchExpr['needsContext'].test(selector) ? 0 : tokens.length;
|
||
while (i--) {
|
||
token = tokens[i];
|
||
// Abort if we hit a combinator
|
||
if (Expr.relative[type = token.type]) {
|
||
break
|
||
}
|
||
if (find = Expr.find[type]) {
|
||
// Search, expanding context for leading sibling combinators
|
||
if (seed = find(token.matches[0].replace(runescape, funescape), rsibling.test(tokens[0].type) && testContext(context.parentNode) || context)) {
|
||
// If seed is empty or no tokens remain, we can return early
|
||
tokens.splice(i, 1);
|
||
selector = seed.length && toSelector(tokens);
|
||
if (!selector) {
|
||
push.apply(results, seed);
|
||
return results
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Compile and execute a filtering function if one is not provided
|
||
// Provide `match` to avoid retokenization if we modified the selector above
|
||
(compiled || compile(selector, match))(seed, context, !documentIsHTML, results, !context || rsibling.test(selector) && testContext(context.parentNode) || context);
|
||
return results
|
||
};
|
||
// One-time assignments
|
||
// Sort stability
|
||
support.sortStable = expando.split('').sort(sortOrder).join('') === expando;
|
||
// Support: Chrome 14-35+
|
||
// Always assume duplicates if they aren't passed to the comparison function
|
||
support.detectDuplicates = !!hasDuplicate;
|
||
// Initialize against the default document
|
||
setDocument();
|
||
// Support: Webkit<537.32 - Safari 6.0.3/Chrome 25 (fixed in Chrome 27)
|
||
// Detached nodes confoundingly follow *each other*
|
||
support.sortDetached = assert(function (div1) {
|
||
// Should return 1, but returns 4 (following)
|
||
return div1.compareDocumentPosition(document.createElement('div')) & 1
|
||
});
|
||
// Support: IE<8
|
||
// Prevent attribute/property "interpolation"
|
||
// http://msdn.microsoft.com/en-us/library/ms536429%28VS.85%29.aspx
|
||
if (!assert(function (div) {
|
||
div.innerHTML = "<a href='#'></a>";
|
||
return div.firstChild.getAttribute('href') === '#'
|
||
})) {
|
||
addHandle('type|href|height|width', function (elem, name, isXML) {
|
||
if (!isXML) {
|
||
return elem.getAttribute(name, name.toLowerCase() === 'type' ? 1 : 2)
|
||
}
|
||
})
|
||
}
|
||
// Support: IE<9
|
||
// Use defaultValue in place of getAttribute("value")
|
||
if (!support.attributes || !assert(function (div) {
|
||
div.innerHTML = '<input/>';
|
||
div.firstChild.setAttribute('value', '');
|
||
return div.firstChild.getAttribute('value') === ''
|
||
})) {
|
||
addHandle('value', function (elem, name, isXML) {
|
||
if (!isXML && elem.nodeName.toLowerCase() === 'input') {
|
||
return elem.defaultValue
|
||
}
|
||
})
|
||
}
|
||
// Support: IE<9
|
||
// Use getAttributeNode to fetch booleans when getAttribute lies
|
||
if (!assert(function (div) {
|
||
return div.getAttribute('disabled') == null
|
||
})) {
|
||
addHandle(booleans, function (elem, name, isXML) {
|
||
var val;
|
||
if (!isXML) {
|
||
return elem[name] === true ? name.toLowerCase() : (val = elem.getAttributeNode(name)) && val.specified ? val.value : null
|
||
}
|
||
})
|
||
}
|
||
return Sizzle
|
||
}(window);
|
||
jQuery.find = Sizzle;
|
||
jQuery.expr = Sizzle.selectors;
|
||
jQuery.expr[':'] = jQuery.expr.pseudos;
|
||
jQuery.uniqueSort = jQuery.unique = Sizzle.uniqueSort;
|
||
jQuery.text = Sizzle.getText;
|
||
jQuery.isXMLDoc = Sizzle.isXML;
|
||
jQuery.contains = Sizzle.contains;
|
||
var dir = function (elem, dir, until) {
|
||
var matched = [], truncate = until !== undefined;
|
||
while ((elem = elem[dir]) && elem.nodeType !== 9) {
|
||
if (elem.nodeType === 1) {
|
||
if (truncate && jQuery(elem).is(until)) {
|
||
break
|
||
}
|
||
matched.push(elem)
|
||
}
|
||
}
|
||
return matched
|
||
};
|
||
var siblings = function (n, elem) {
|
||
var matched = [];
|
||
for (; n; n = n.nextSibling) {
|
||
if (n.nodeType === 1 && n !== elem) {
|
||
matched.push(n)
|
||
}
|
||
}
|
||
return matched
|
||
};
|
||
var rneedsContext = jQuery.expr.match.needsContext;
|
||
var rsingleTag = /^<([\w-]+)\s*\/?>(?:<\/\1>|)$/;
|
||
var risSimple = /^.[^:#\[\.,]*$/;
|
||
// Implement the identical functionality for filter and not
|
||
function winnow(elements, qualifier, not) {
|
||
if (jQuery.isFunction(qualifier)) {
|
||
return jQuery.grep(elements, function (elem, i) {
|
||
/* jshint -W018 */
|
||
return !!qualifier.call(elem, i, elem) !== not
|
||
})
|
||
}
|
||
if (qualifier.nodeType) {
|
||
return jQuery.grep(elements, function (elem) {
|
||
return elem === qualifier !== not
|
||
})
|
||
}
|
||
if (typeof qualifier === 'string') {
|
||
if (risSimple.test(qualifier)) {
|
||
return jQuery.filter(qualifier, elements, not)
|
||
}
|
||
qualifier = jQuery.filter(qualifier, elements)
|
||
}
|
||
return jQuery.grep(elements, function (elem) {
|
||
return indexOf.call(qualifier, elem) > -1 !== not
|
||
})
|
||
}
|
||
jQuery.filter = function (expr, elems, not) {
|
||
var elem = elems[0];
|
||
if (not) {
|
||
expr = ':not(' + expr + ')'
|
||
}
|
||
return elems.length === 1 && elem.nodeType === 1 ? jQuery.find.matchesSelector(elem, expr) ? [elem] : [] : jQuery.find.matches(expr, jQuery.grep(elems, function (elem) {
|
||
return elem.nodeType === 1
|
||
}))
|
||
};
|
||
jQuery.fn.extend({
|
||
find: function (selector) {
|
||
var i, len = this.length, ret = [], self = this;
|
||
if (typeof selector !== 'string') {
|
||
return this.pushStack(jQuery(selector).filter(function () {
|
||
for (i = 0; i < len; i++) {
|
||
if (jQuery.contains(self[i], this)) {
|
||
return true
|
||
}
|
||
}
|
||
}))
|
||
}
|
||
for (i = 0; i < len; i++) {
|
||
jQuery.find(selector, self[i], ret)
|
||
}
|
||
// Needed because $( selector, context ) becomes $( context ).find( selector )
|
||
ret = this.pushStack(len > 1 ? jQuery.unique(ret) : ret);
|
||
ret.selector = this.selector ? this.selector + ' ' + selector : selector;
|
||
return ret
|
||
},
|
||
filter: function (selector) {
|
||
return this.pushStack(winnow(this, selector || [], false))
|
||
},
|
||
not: function (selector) {
|
||
return this.pushStack(winnow(this, selector || [], true))
|
||
},
|
||
is: function (selector) {
|
||
return !!winnow(this, // If this is a positional/relative selector, check membership in the returned set
|
||
// so $("p:first").is("p:last") won't return true for a doc with two "p".
|
||
typeof selector === 'string' && rneedsContext.test(selector) ? jQuery(selector) : selector || [], false).length
|
||
}
|
||
});
|
||
// Initialize a jQuery object
|
||
// A central reference to the root jQuery(document)
|
||
var rootjQuery,
|
||
// A simple way to check for HTML strings
|
||
// Prioritize #id over <tag> to avoid XSS via location.hash (#9521)
|
||
// Strict HTML recognition (#11290: must start with <)
|
||
rquickExpr = /^(?:\s*(<[\w\W]+>)[^>]*|#([\w-]*))$/, init = jQuery.fn.init = function (selector, context, root) {
|
||
var match, elem;
|
||
// HANDLE: $(""), $(null), $(undefined), $(false)
|
||
if (!selector) {
|
||
return this
|
||
}
|
||
// Method init() accepts an alternate rootjQuery
|
||
// so migrate can support jQuery.sub (gh-2101)
|
||
root = root || rootjQuery;
|
||
// Handle HTML strings
|
||
if (typeof selector === 'string') {
|
||
if (selector[0] === '<' && selector[selector.length - 1] === '>' && selector.length >= 3) {
|
||
// Assume that strings that start and end with <> are HTML and skip the regex check
|
||
match = [
|
||
null,
|
||
selector,
|
||
null
|
||
]
|
||
} else {
|
||
match = rquickExpr.exec(selector)
|
||
}
|
||
// Match html or make sure no context is specified for #id
|
||
if (match && (match[1] || !context)) {
|
||
// HANDLE: $(html) -> $(array)
|
||
if (match[1]) {
|
||
context = context instanceof jQuery ? context[0] : context;
|
||
// Option to run scripts is true for back-compat
|
||
// Intentionally let the error be thrown if parseHTML is not present
|
||
jQuery.merge(this, jQuery.parseHTML(match[1], context && context.nodeType ? context.ownerDocument || context : document, true));
|
||
// HANDLE: $(html, props)
|
||
if (rsingleTag.test(match[1]) && jQuery.isPlainObject(context)) {
|
||
for (match in context) {
|
||
// Properties of context are called as methods if possible
|
||
if (jQuery.isFunction(this[match])) {
|
||
this[match](context[match]) // ...and otherwise set as attributes
|
||
} else {
|
||
this.attr(match, context[match])
|
||
}
|
||
}
|
||
}
|
||
return this // HANDLE: $(#id)
|
||
} else {
|
||
elem = document.getElementById(match[2]);
|
||
// Support: Blackberry 4.6
|
||
// gEBID returns nodes no longer in the document (#6963)
|
||
if (elem && elem.parentNode) {
|
||
// Inject the element directly into the jQuery object
|
||
this.length = 1;
|
||
this[0] = elem
|
||
}
|
||
this.context = document;
|
||
this.selector = selector;
|
||
return this
|
||
} // HANDLE: $(expr, $(...))
|
||
} else if (!context || context.jquery) {
|
||
return (context || root).find(selector) // HANDLE: $(expr, context)
|
||
// (which is just equivalent to: $(context).find(expr)
|
||
} else {
|
||
return this.constructor(context).find(selector)
|
||
} // HANDLE: $(DOMElement)
|
||
} else if (selector.nodeType) {
|
||
this.context = this[0] = selector;
|
||
this.length = 1;
|
||
return this // HANDLE: $(function)
|
||
// Shortcut for document ready
|
||
} else if (jQuery.isFunction(selector)) {
|
||
return root.ready !== undefined ? root.ready(selector) : // Execute immediately if ready is not present
|
||
selector(jQuery)
|
||
}
|
||
if (selector.selector !== undefined) {
|
||
this.selector = selector.selector;
|
||
this.context = selector.context
|
||
}
|
||
return jQuery.makeArray(selector, this)
|
||
};
|
||
// Give the init function the jQuery prototype for later instantiation
|
||
init.prototype = jQuery.fn;
|
||
// Initialize central reference
|
||
rootjQuery = jQuery(document);
|
||
var rparentsprev = /^(?:parents|prev(?:Until|All))/,
|
||
// Methods guaranteed to produce a unique set when starting from a unique set
|
||
guaranteedUnique = {
|
||
children: true,
|
||
contents: true,
|
||
next: true,
|
||
prev: true
|
||
};
|
||
jQuery.fn.extend({
|
||
has: function (target) {
|
||
var targets = jQuery(target, this), l = targets.length;
|
||
return this.filter(function () {
|
||
var i = 0;
|
||
for (; i < l; i++) {
|
||
if (jQuery.contains(this, targets[i])) {
|
||
return true
|
||
}
|
||
}
|
||
})
|
||
},
|
||
closest: function (selectors, context) {
|
||
var cur, i = 0, l = this.length, matched = [], pos = rneedsContext.test(selectors) || typeof selectors !== 'string' ? jQuery(selectors, context || this.context) : 0;
|
||
for (; i < l; i++) {
|
||
for (cur = this[i]; cur && cur !== context; cur = cur.parentNode) {
|
||
// Always skip document fragments
|
||
if (cur.nodeType < 11 && (pos ? pos.index(cur) > -1 : // Don't pass non-elements to Sizzle
|
||
cur.nodeType === 1 && jQuery.find.matchesSelector(cur, selectors))) {
|
||
matched.push(cur);
|
||
break
|
||
}
|
||
}
|
||
}
|
||
return this.pushStack(matched.length > 1 ? jQuery.uniqueSort(matched) : matched)
|
||
},
|
||
// Determine the position of an element within the set
|
||
index: function (elem) {
|
||
// No argument, return index in parent
|
||
if (!elem) {
|
||
return this[0] && this[0].parentNode ? this.first().prevAll().length : -1
|
||
}
|
||
// Index in selector
|
||
if (typeof elem === 'string') {
|
||
return indexOf.call(jQuery(elem), this[0])
|
||
}
|
||
// Locate the position of the desired element
|
||
return indexOf.call(this, // If it receives a jQuery object, the first element is used
|
||
elem.jquery ? elem[0] : elem)
|
||
},
|
||
add: function (selector, context) {
|
||
return this.pushStack(jQuery.uniqueSort(jQuery.merge(this.get(), jQuery(selector, context))))
|
||
},
|
||
addBack: function (selector) {
|
||
return this.add(selector == null ? this.prevObject : this.prevObject.filter(selector))
|
||
}
|
||
});
|
||
function sibling(cur, dir) {
|
||
while ((cur = cur[dir]) && cur.nodeType !== 1) {
|
||
}
|
||
return cur
|
||
}
|
||
jQuery.each({
|
||
parent: function (elem) {
|
||
var parent = elem.parentNode;
|
||
return parent && parent.nodeType !== 11 ? parent : null
|
||
},
|
||
parents: function (elem) {
|
||
return dir(elem, 'parentNode')
|
||
},
|
||
parentsUntil: function (elem, i, until) {
|
||
return dir(elem, 'parentNode', until)
|
||
},
|
||
next: function (elem) {
|
||
return sibling(elem, 'nextSibling')
|
||
},
|
||
prev: function (elem) {
|
||
return sibling(elem, 'previousSibling')
|
||
},
|
||
nextAll: function (elem) {
|
||
return dir(elem, 'nextSibling')
|
||
},
|
||
prevAll: function (elem) {
|
||
return dir(elem, 'previousSibling')
|
||
},
|
||
nextUntil: function (elem, i, until) {
|
||
return dir(elem, 'nextSibling', until)
|
||
},
|
||
prevUntil: function (elem, i, until) {
|
||
return dir(elem, 'previousSibling', until)
|
||
},
|
||
siblings: function (elem) {
|
||
return siblings((elem.parentNode || {}).firstChild, elem)
|
||
},
|
||
children: function (elem) {
|
||
return siblings(elem.firstChild)
|
||
},
|
||
contents: function (elem) {
|
||
return elem.contentDocument || jQuery.merge([], elem.childNodes)
|
||
}
|
||
}, function (name, fn) {
|
||
jQuery.fn[name] = function (until, selector) {
|
||
var matched = jQuery.map(this, fn, until);
|
||
if (name.slice(-5) !== 'Until') {
|
||
selector = until
|
||
}
|
||
if (selector && typeof selector === 'string') {
|
||
matched = jQuery.filter(selector, matched)
|
||
}
|
||
if (this.length > 1) {
|
||
// Remove duplicates
|
||
if (!guaranteedUnique[name]) {
|
||
jQuery.uniqueSort(matched)
|
||
}
|
||
// Reverse order for parents* and prev-derivatives
|
||
if (rparentsprev.test(name)) {
|
||
matched.reverse()
|
||
}
|
||
}
|
||
return this.pushStack(matched)
|
||
}
|
||
});
|
||
var rnotwhite = /\S+/g;
|
||
// Convert String-formatted options into Object-formatted ones
|
||
function createOptions(options) {
|
||
var object = {};
|
||
jQuery.each(options.match(rnotwhite) || [], function (_, flag) {
|
||
object[flag] = true
|
||
});
|
||
return object
|
||
}
|
||
/*
|
||
* Create a callback list using the following parameters:
|
||
*
|
||
* options: an optional list of space-separated options that will change how
|
||
* the callback list behaves or a more traditional option object
|
||
*
|
||
* By default a callback list will act like an event callback list and can be
|
||
* "fired" multiple times.
|
||
*
|
||
* Possible options:
|
||
*
|
||
* once: will ensure the callback list can only be fired once (like a Deferred)
|
||
*
|
||
* memory: will keep track of previous values and will call any callback added
|
||
* after the list has been fired right away with the latest "memorized"
|
||
* values (like a Deferred)
|
||
*
|
||
* unique: will ensure a callback can only be added once (no duplicate in the list)
|
||
*
|
||
* stopOnFalse: interrupt callings when a callback returns false
|
||
*
|
||
*/
|
||
jQuery.Callbacks = function (options) {
|
||
// Convert options from String-formatted to Object-formatted if needed
|
||
// (we check in cache first)
|
||
options = typeof options === 'string' ? createOptions(options) : jQuery.extend({}, options);
|
||
var
|
||
// Flag to know if list is currently firing
|
||
firing,
|
||
// Last fire value for non-forgettable lists
|
||
memory,
|
||
// Flag to know if list was already fired
|
||
fired,
|
||
// Flag to prevent firing
|
||
locked,
|
||
// Actual callback list
|
||
list = [],
|
||
// Queue of execution data for repeatable lists
|
||
queue = [],
|
||
// Index of currently firing callback (modified by add/remove as needed)
|
||
firingIndex = -1,
|
||
// Fire callbacks
|
||
fire = function () {
|
||
// Enforce single-firing
|
||
locked = options.once;
|
||
// Execute callbacks for all pending executions,
|
||
// respecting firingIndex overrides and runtime changes
|
||
fired = firing = true;
|
||
for (; queue.length; firingIndex = -1) {
|
||
memory = queue.shift();
|
||
while (++firingIndex < list.length) {
|
||
// Run callback and check for early termination
|
||
if (list[firingIndex].apply(memory[0], memory[1]) === false && options.stopOnFalse) {
|
||
// Jump to end and forget the data so .add doesn't re-fire
|
||
firingIndex = list.length;
|
||
memory = false
|
||
}
|
||
}
|
||
}
|
||
// Forget the data if we're done with it
|
||
if (!options.memory) {
|
||
memory = false
|
||
}
|
||
firing = false;
|
||
// Clean up if we're done firing for good
|
||
if (locked) {
|
||
// Keep an empty list if we have data for future add calls
|
||
if (memory) {
|
||
list = [] // Otherwise, this object is spent
|
||
} else {
|
||
list = ''
|
||
}
|
||
}
|
||
},
|
||
// Actual Callbacks object
|
||
self = {
|
||
// Add a callback or a collection of callbacks to the list
|
||
add: function () {
|
||
if (list) {
|
||
// If we have memory from a past run, we should fire after adding
|
||
if (memory && !firing) {
|
||
firingIndex = list.length - 1;
|
||
queue.push(memory)
|
||
}
|
||
(function add(args) {
|
||
jQuery.each(args, function (_, arg) {
|
||
if (jQuery.isFunction(arg)) {
|
||
if (!options.unique || !self.has(arg)) {
|
||
list.push(arg)
|
||
}
|
||
} else if (arg && arg.length && jQuery.type(arg) !== 'string') {
|
||
// Inspect recursively
|
||
add(arg)
|
||
}
|
||
})
|
||
}(arguments));
|
||
if (memory && !firing) {
|
||
fire()
|
||
}
|
||
}
|
||
return this
|
||
},
|
||
// Remove a callback from the list
|
||
remove: function () {
|
||
jQuery.each(arguments, function (_, arg) {
|
||
var index;
|
||
while ((index = jQuery.inArray(arg, list, index)) > -1) {
|
||
list.splice(index, 1);
|
||
// Handle firing indexes
|
||
if (index <= firingIndex) {
|
||
firingIndex--
|
||
}
|
||
}
|
||
});
|
||
return this
|
||
},
|
||
// Check if a given callback is in the list.
|
||
// If no argument is given, return whether or not list has callbacks attached.
|
||
has: function (fn) {
|
||
return fn ? jQuery.inArray(fn, list) > -1 : list.length > 0
|
||
},
|
||
// Remove all callbacks from the list
|
||
empty: function () {
|
||
if (list) {
|
||
list = []
|
||
}
|
||
return this
|
||
},
|
||
// Disable .fire and .add
|
||
// Abort any current/pending executions
|
||
// Clear all callbacks and values
|
||
disable: function () {
|
||
locked = queue = [];
|
||
list = memory = '';
|
||
return this
|
||
},
|
||
disabled: function () {
|
||
return !list
|
||
},
|
||
// Disable .fire
|
||
// Also disable .add unless we have memory (since it would have no effect)
|
||
// Abort any pending executions
|
||
lock: function () {
|
||
locked = queue = [];
|
||
if (!memory) {
|
||
list = memory = ''
|
||
}
|
||
return this
|
||
},
|
||
locked: function () {
|
||
return !!locked
|
||
},
|
||
// Call all callbacks with the given context and arguments
|
||
fireWith: function (context, args) {
|
||
if (!locked) {
|
||
args = args || [];
|
||
args = [
|
||
context,
|
||
args.slice ? args.slice() : args
|
||
];
|
||
queue.push(args);
|
||
if (!firing) {
|
||
fire()
|
||
}
|
||
}
|
||
return this
|
||
},
|
||
// Call all the callbacks with the given arguments
|
||
fire: function () {
|
||
self.fireWith(this, arguments);
|
||
return this
|
||
},
|
||
// To know if the callbacks have already been called at least once
|
||
fired: function () {
|
||
return !!fired
|
||
}
|
||
};
|
||
return self
|
||
};
|
||
jQuery.extend({
|
||
Deferred: function (func) {
|
||
var tuples = [
|
||
// action, add listener, listener list, final state
|
||
[
|
||
'resolve',
|
||
'done',
|
||
jQuery.Callbacks('once memory'),
|
||
'resolved'
|
||
],
|
||
[
|
||
'reject',
|
||
'fail',
|
||
jQuery.Callbacks('once memory'),
|
||
'rejected'
|
||
],
|
||
[
|
||
'notify',
|
||
'progress',
|
||
jQuery.Callbacks('memory')
|
||
]
|
||
], state = 'pending', promise = {
|
||
state: function () {
|
||
return state
|
||
},
|
||
always: function () {
|
||
deferred.done(arguments).fail(arguments);
|
||
return this
|
||
},
|
||
then: function () {
|
||
var fns = arguments;
|
||
return jQuery.Deferred(function (newDefer) {
|
||
jQuery.each(tuples, function (i, tuple) {
|
||
var fn = jQuery.isFunction(fns[i]) && fns[i];
|
||
// deferred[ done | fail | progress ] for forwarding actions to newDefer
|
||
deferred[tuple[1]](function () {
|
||
var returned = fn && fn.apply(this, arguments);
|
||
if (returned && jQuery.isFunction(returned.promise)) {
|
||
returned.promise().progress(newDefer.notify).done(newDefer.resolve).fail(newDefer.reject)
|
||
} else {
|
||
newDefer[tuple[0] + 'With'](this === promise ? newDefer.promise() : this, fn ? [returned] : arguments)
|
||
}
|
||
})
|
||
});
|
||
fns = null
|
||
}).promise()
|
||
},
|
||
// Get a promise for this deferred
|
||
// If obj is provided, the promise aspect is added to the object
|
||
promise: function (obj) {
|
||
return obj != null ? jQuery.extend(obj, promise) : promise
|
||
}
|
||
}, deferred = {};
|
||
// Keep pipe for back-compat
|
||
promise.pipe = promise.then;
|
||
// Add list-specific methods
|
||
jQuery.each(tuples, function (i, tuple) {
|
||
var list = tuple[2], stateString = tuple[3];
|
||
// promise[ done | fail | progress ] = list.add
|
||
promise[tuple[1]] = list.add;
|
||
// Handle state
|
||
if (stateString) {
|
||
list.add(function () {
|
||
// state = [ resolved | rejected ]
|
||
state = stateString // [ reject_list | resolve_list ].disable; progress_list.lock
|
||
}, tuples[i ^ 1][2].disable, tuples[2][2].lock)
|
||
}
|
||
// deferred[ resolve | reject | notify ]
|
||
deferred[tuple[0]] = function () {
|
||
deferred[tuple[0] + 'With'](this === deferred ? promise : this, arguments);
|
||
return this
|
||
};
|
||
deferred[tuple[0] + 'With'] = list.fireWith
|
||
});
|
||
// Make the deferred a promise
|
||
promise.promise(deferred);
|
||
// Call given func if any
|
||
if (func) {
|
||
func.call(deferred, deferred)
|
||
}
|
||
// All done!
|
||
return deferred
|
||
},
|
||
// Deferred helper
|
||
when: function (subordinate) {
|
||
var i = 0, resolveValues = slice.call(arguments), length = resolveValues.length,
|
||
// the count of uncompleted subordinates
|
||
remaining = length !== 1 || subordinate && jQuery.isFunction(subordinate.promise) ? length : 0,
|
||
// the master Deferred.
|
||
// If resolveValues consist of only a single Deferred, just use that.
|
||
deferred = remaining === 1 ? subordinate : jQuery.Deferred(),
|
||
// Update function for both resolve and progress values
|
||
updateFunc = function (i, contexts, values) {
|
||
return function (value) {
|
||
contexts[i] = this;
|
||
values[i] = arguments.length > 1 ? slice.call(arguments) : value;
|
||
if (values === progressValues) {
|
||
deferred.notifyWith(contexts, values)
|
||
} else if (!--remaining) {
|
||
deferred.resolveWith(contexts, values)
|
||
}
|
||
}
|
||
}, progressValues, progressContexts, resolveContexts;
|
||
// Add listeners to Deferred subordinates; treat others as resolved
|
||
if (length > 1) {
|
||
progressValues = new Array(length);
|
||
progressContexts = new Array(length);
|
||
resolveContexts = new Array(length);
|
||
for (; i < length; i++) {
|
||
if (resolveValues[i] && jQuery.isFunction(resolveValues[i].promise)) {
|
||
resolveValues[i].promise().progress(updateFunc(i, progressContexts, progressValues)).done(updateFunc(i, resolveContexts, resolveValues)).fail(deferred.reject)
|
||
} else {
|
||
--remaining
|
||
}
|
||
}
|
||
}
|
||
// If we're not waiting on anything, resolve the master
|
||
if (!remaining) {
|
||
deferred.resolveWith(resolveContexts, resolveValues)
|
||
}
|
||
return deferred.promise()
|
||
}
|
||
});
|
||
// The deferred used on DOM ready
|
||
var readyList;
|
||
jQuery.fn.ready = function (fn) {
|
||
// Add the callback
|
||
jQuery.ready.promise().done(fn);
|
||
return this
|
||
};
|
||
jQuery.extend({
|
||
// Is the DOM ready to be used? Set to true once it occurs.
|
||
isReady: false,
|
||
// A counter to track how many items to wait for before
|
||
// the ready event fires. See #6781
|
||
readyWait: 1,
|
||
// Hold (or release) the ready event
|
||
holdReady: function (hold) {
|
||
if (hold) {
|
||
jQuery.readyWait++
|
||
} else {
|
||
jQuery.ready(true)
|
||
}
|
||
},
|
||
// Handle when the DOM is ready
|
||
ready: function (wait) {
|
||
// Abort if there are pending holds or we're already ready
|
||
if (wait === true ? --jQuery.readyWait : jQuery.isReady) {
|
||
return
|
||
}
|
||
// Remember that the DOM is ready
|
||
jQuery.isReady = true;
|
||
// If a normal DOM Ready event fired, decrement, and wait if need be
|
||
if (wait !== true && --jQuery.readyWait > 0) {
|
||
return
|
||
}
|
||
// If there are functions bound, to execute
|
||
readyList.resolveWith(document, [jQuery]);
|
||
// Trigger any bound ready events
|
||
if (jQuery.fn.triggerHandler) {
|
||
jQuery(document).triggerHandler('ready');
|
||
jQuery(document).off('ready')
|
||
}
|
||
}
|
||
});
|
||
/**
|
||
* The ready event handler and self cleanup method
|
||
*/
|
||
function completed() {
|
||
document.removeEventListener('DOMContentLoaded', completed);
|
||
window.removeEventListener('load', completed);
|
||
jQuery.ready()
|
||
}
|
||
jQuery.ready.promise = function (obj) {
|
||
if (!readyList) {
|
||
readyList = jQuery.Deferred();
|
||
// Catch cases where $(document).ready() is called
|
||
// after the browser event has already occurred.
|
||
// Support: IE9-10 only
|
||
// Older IE sometimes signals "interactive" too soon
|
||
if (document.readyState === 'complete' || document.readyState !== 'loading' && !document.documentElement.doScroll) {
|
||
// Handle it asynchronously to allow scripts the opportunity to delay ready
|
||
window.setTimeout(jQuery.ready)
|
||
} else {
|
||
// Use the handy event callback
|
||
document.addEventListener('DOMContentLoaded', completed);
|
||
// A fallback to window.onload, that will always work
|
||
window.addEventListener('load', completed)
|
||
}
|
||
}
|
||
return readyList.promise(obj)
|
||
};
|
||
// Kick off the DOM ready check even if the user does not
|
||
jQuery.ready.promise();
|
||
// Multifunctional method to get and set values of a collection
|
||
// The value/s can optionally be executed if it's a function
|
||
var access = function (elems, fn, key, value, chainable, emptyGet, raw) {
|
||
var i = 0, len = elems.length, bulk = key == null;
|
||
// Sets many values
|
||
if (jQuery.type(key) === 'object') {
|
||
chainable = true;
|
||
for (i in key) {
|
||
access(elems, fn, i, key[i], true, emptyGet, raw)
|
||
} // Sets one value
|
||
} else if (value !== undefined) {
|
||
chainable = true;
|
||
if (!jQuery.isFunction(value)) {
|
||
raw = true
|
||
}
|
||
if (bulk) {
|
||
// Bulk operations run against the entire set
|
||
if (raw) {
|
||
fn.call(elems, value);
|
||
fn = null // ...except when executing function values
|
||
} else {
|
||
bulk = fn;
|
||
fn = function (elem, key, value) {
|
||
return bulk.call(jQuery(elem), value)
|
||
}
|
||
}
|
||
}
|
||
if (fn) {
|
||
for (; i < len; i++) {
|
||
fn(elems[i], key, raw ? value : value.call(elems[i], i, fn(elems[i], key)))
|
||
}
|
||
}
|
||
}
|
||
return chainable ? elems : // Gets
|
||
bulk ? fn.call(elems) : len ? fn(elems[0], key) : emptyGet
|
||
};
|
||
var acceptData = function (owner) {
|
||
// Accepts only:
|
||
// - Node
|
||
// - Node.ELEMENT_NODE
|
||
// - Node.DOCUMENT_NODE
|
||
// - Object
|
||
// - Any
|
||
/* jshint -W018 */
|
||
return owner.nodeType === 1 || owner.nodeType === 9 || !+owner.nodeType
|
||
};
|
||
function Data() {
|
||
this.expando = jQuery.expando + Data.uid++
|
||
}
|
||
Data.uid = 1;
|
||
Data.prototype = {
|
||
register: function (owner, initial) {
|
||
var value = initial || {};
|
||
// If it is a node unlikely to be stringify-ed or looped over
|
||
// use plain assignment
|
||
if (owner.nodeType) {
|
||
owner[this.expando] = value // Otherwise secure it in a non-enumerable, non-writable property
|
||
// configurability must be true to allow the property to be
|
||
// deleted with the delete operator
|
||
} else {
|
||
Object.defineProperty(owner, this.expando, {
|
||
value: value,
|
||
writable: true,
|
||
configurable: true
|
||
})
|
||
}
|
||
return owner[this.expando]
|
||
},
|
||
cache: function (owner) {
|
||
// We can accept data for non-element nodes in modern browsers,
|
||
// but we should not, see #8335.
|
||
// Always return an empty object.
|
||
if (!acceptData(owner)) {
|
||
return {}
|
||
}
|
||
// Check if the owner object already has a cache
|
||
var value = owner[this.expando];
|
||
// If not, create one
|
||
if (!value) {
|
||
value = {};
|
||
// We can accept data for non-element nodes in modern browsers,
|
||
// but we should not, see #8335.
|
||
// Always return an empty object.
|
||
if (acceptData(owner)) {
|
||
// If it is a node unlikely to be stringify-ed or looped over
|
||
// use plain assignment
|
||
if (owner.nodeType) {
|
||
owner[this.expando] = value // Otherwise secure it in a non-enumerable property
|
||
// configurable must be true to allow the property to be
|
||
// deleted when data is removed
|
||
} else {
|
||
Object.defineProperty(owner, this.expando, {
|
||
value: value,
|
||
configurable: true
|
||
})
|
||
}
|
||
}
|
||
}
|
||
return value
|
||
},
|
||
set: function (owner, data, value) {
|
||
var prop, cache = this.cache(owner);
|
||
// Handle: [ owner, key, value ] args
|
||
if (typeof data === 'string') {
|
||
cache[data] = value // Handle: [ owner, { properties } ] args
|
||
} else {
|
||
// Copy the properties one-by-one to the cache object
|
||
for (prop in data) {
|
||
cache[prop] = data[prop]
|
||
}
|
||
}
|
||
return cache
|
||
},
|
||
get: function (owner, key) {
|
||
return key === undefined ? this.cache(owner) : owner[this.expando] && owner[this.expando][key]
|
||
},
|
||
access: function (owner, key, value) {
|
||
var stored;
|
||
// In cases where either:
|
||
//
|
||
// 1. No key was specified
|
||
// 2. A string key was specified, but no value provided
|
||
//
|
||
// Take the "read" path and allow the get method to determine
|
||
// which value to return, respectively either:
|
||
//
|
||
// 1. The entire cache object
|
||
// 2. The data stored at the key
|
||
//
|
||
if (key === undefined || key && typeof key === 'string' && value === undefined) {
|
||
stored = this.get(owner, key);
|
||
return stored !== undefined ? stored : this.get(owner, jQuery.camelCase(key))
|
||
}
|
||
// When the key is not a string, or both a key and value
|
||
// are specified, set or extend (existing objects) with either:
|
||
//
|
||
// 1. An object of properties
|
||
// 2. A key and value
|
||
//
|
||
this.set(owner, key, value);
|
||
// Since the "set" path can have two possible entry points
|
||
// return the expected data based on which path was taken[*]
|
||
return value !== undefined ? value : key
|
||
},
|
||
remove: function (owner, key) {
|
||
var i, name, camel, cache = owner[this.expando];
|
||
if (cache === undefined) {
|
||
return
|
||
}
|
||
if (key === undefined) {
|
||
this.register(owner)
|
||
} else {
|
||
// Support array or space separated string of keys
|
||
if (jQuery.isArray(key)) {
|
||
// If "name" is an array of keys...
|
||
// When data is initially created, via ("key", "val") signature,
|
||
// keys will be converted to camelCase.
|
||
// Since there is no way to tell _how_ a key was added, remove
|
||
// both plain key and camelCase key. #12786
|
||
// This will only penalize the array argument path.
|
||
name = key.concat(key.map(jQuery.camelCase))
|
||
} else {
|
||
camel = jQuery.camelCase(key);
|
||
// Try the string as a key before any manipulation
|
||
if (key in cache) {
|
||
name = [
|
||
key,
|
||
camel
|
||
]
|
||
} else {
|
||
// If a key with the spaces exists, use it.
|
||
// Otherwise, create an array by matching non-whitespace
|
||
name = camel;
|
||
name = name in cache ? [name] : name.match(rnotwhite) || []
|
||
}
|
||
}
|
||
i = name.length;
|
||
while (i--) {
|
||
delete cache[name[i]]
|
||
}
|
||
}
|
||
// Remove the expando if there's no more data
|
||
if (key === undefined || jQuery.isEmptyObject(cache)) {
|
||
// Support: Chrome <= 35-45+
|
||
// Webkit & Blink performance suffers when deleting properties
|
||
// from DOM nodes, so set to undefined instead
|
||
// https://code.google.com/p/chromium/issues/detail?id=378607
|
||
if (owner.nodeType) {
|
||
owner[this.expando] = undefined
|
||
} else {
|
||
delete owner[this.expando]
|
||
}
|
||
}
|
||
},
|
||
hasData: function (owner) {
|
||
var cache = owner[this.expando];
|
||
return cache !== undefined && !jQuery.isEmptyObject(cache)
|
||
}
|
||
};
|
||
var dataPriv = new Data;
|
||
var dataUser = new Data;
|
||
// Implementation Summary
|
||
//
|
||
// 1. Enforce API surface and semantic compatibility with 1.9.x branch
|
||
// 2. Improve the module's maintainability by reducing the storage
|
||
// paths to a single mechanism.
|
||
// 3. Use the same single mechanism to support "private" and "user" data.
|
||
// 4. _Never_ expose "private" data to user code (TODO: Drop _data, _removeData)
|
||
// 5. Avoid exposing implementation details on user objects (eg. expando properties)
|
||
// 6. Provide a clear path for implementation upgrade to WeakMap in 2014
|
||
var rbrace = /^(?:\{[\w\W]*\}|\[[\w\W]*\])$/, rmultiDash = /[A-Z]/g;
|
||
function dataAttr(elem, key, data) {
|
||
var name;
|
||
// If nothing was found internally, try to fetch any
|
||
// data from the HTML5 data-* attribute
|
||
if (data === undefined && elem.nodeType === 1) {
|
||
name = 'data-' + key.replace(rmultiDash, '-$&').toLowerCase();
|
||
data = elem.getAttribute(name);
|
||
if (typeof data === 'string') {
|
||
try {
|
||
data = data === 'true' ? true : data === 'false' ? false : data === 'null' ? null : // Only convert to a number if it doesn't change the string
|
||
+data + '' === data ? +data : rbrace.test(data) ? jQuery.parseJSON(data) : data
|
||
} catch (e) {
|
||
}
|
||
// Make sure we set the data so it isn't changed later
|
||
dataUser.set(elem, key, data)
|
||
} else {
|
||
data = undefined
|
||
}
|
||
}
|
||
return data
|
||
}
|
||
jQuery.extend({
|
||
hasData: function (elem) {
|
||
return dataUser.hasData(elem) || dataPriv.hasData(elem)
|
||
},
|
||
data: function (elem, name, data) {
|
||
return dataUser.access(elem, name, data)
|
||
},
|
||
removeData: function (elem, name) {
|
||
dataUser.remove(elem, name)
|
||
},
|
||
// TODO: Now that all calls to _data and _removeData have been replaced
|
||
// with direct calls to dataPriv methods, these can be deprecated.
|
||
_data: function (elem, name, data) {
|
||
return dataPriv.access(elem, name, data)
|
||
},
|
||
_removeData: function (elem, name) {
|
||
dataPriv.remove(elem, name)
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
data: function (key, value) {
|
||
var i, name, data, elem = this[0], attrs = elem && elem.attributes;
|
||
// Gets all values
|
||
if (key === undefined) {
|
||
if (this.length) {
|
||
data = dataUser.get(elem);
|
||
if (elem.nodeType === 1 && !dataPriv.get(elem, 'hasDataAttrs')) {
|
||
i = attrs.length;
|
||
while (i--) {
|
||
// Support: IE11+
|
||
// The attrs elements can be null (#14894)
|
||
if (attrs[i]) {
|
||
name = attrs[i].name;
|
||
if (name.indexOf('data-') === 0) {
|
||
name = jQuery.camelCase(name.slice(5));
|
||
dataAttr(elem, name, data[name])
|
||
}
|
||
}
|
||
}
|
||
dataPriv.set(elem, 'hasDataAttrs', true)
|
||
}
|
||
}
|
||
return data
|
||
}
|
||
// Sets multiple values
|
||
if (typeof key === 'object') {
|
||
return this.each(function () {
|
||
dataUser.set(this, key)
|
||
})
|
||
}
|
||
return access(this, function (value) {
|
||
var data, camelKey;
|
||
// The calling jQuery object (element matches) is not empty
|
||
// (and therefore has an element appears at this[ 0 ]) and the
|
||
// `value` parameter was not undefined. An empty jQuery object
|
||
// will result in `undefined` for elem = this[ 0 ] which will
|
||
// throw an exception if an attempt to read a data cache is made.
|
||
if (elem && value === undefined) {
|
||
// Attempt to get data from the cache
|
||
// with the key as-is
|
||
data = dataUser.get(elem, key) || // Try to find dashed key if it exists (gh-2779)
|
||
// This is for 2.2.x only
|
||
dataUser.get(elem, key.replace(rmultiDash, '-$&').toLowerCase());
|
||
if (data !== undefined) {
|
||
return data
|
||
}
|
||
camelKey = jQuery.camelCase(key);
|
||
// Attempt to get data from the cache
|
||
// with the key camelized
|
||
data = dataUser.get(elem, camelKey);
|
||
if (data !== undefined) {
|
||
return data
|
||
}
|
||
// Attempt to "discover" the data in
|
||
// HTML5 custom data-* attrs
|
||
data = dataAttr(elem, camelKey, undefined);
|
||
if (data !== undefined) {
|
||
return data
|
||
}
|
||
// We tried really hard, but the data doesn't exist.
|
||
return
|
||
}
|
||
// Set the data...
|
||
camelKey = jQuery.camelCase(key);
|
||
this.each(function () {
|
||
// First, attempt to store a copy or reference of any
|
||
// data that might've been store with a camelCased key.
|
||
var data = dataUser.get(this, camelKey);
|
||
// For HTML5 data-* attribute interop, we have to
|
||
// store property names with dashes in a camelCase form.
|
||
// This might not apply to all properties...*
|
||
dataUser.set(this, camelKey, value);
|
||
// *... In the case of properties that might _actually_
|
||
// have dashes, we need to also store a copy of that
|
||
// unchanged property.
|
||
if (key.indexOf('-') > -1 && data !== undefined) {
|
||
dataUser.set(this, key, value)
|
||
}
|
||
})
|
||
}, null, value, arguments.length > 1, null, true)
|
||
},
|
||
removeData: function (key) {
|
||
return this.each(function () {
|
||
dataUser.remove(this, key)
|
||
})
|
||
}
|
||
});
|
||
jQuery.extend({
|
||
queue: function (elem, type, data) {
|
||
var queue;
|
||
if (elem) {
|
||
type = (type || 'fx') + 'queue';
|
||
queue = dataPriv.get(elem, type);
|
||
// Speed up dequeue by getting out quickly if this is just a lookup
|
||
if (data) {
|
||
if (!queue || jQuery.isArray(data)) {
|
||
queue = dataPriv.access(elem, type, jQuery.makeArray(data))
|
||
} else {
|
||
queue.push(data)
|
||
}
|
||
}
|
||
return queue || []
|
||
}
|
||
},
|
||
dequeue: function (elem, type) {
|
||
type = type || 'fx';
|
||
var queue = jQuery.queue(elem, type), startLength = queue.length, fn = queue.shift(), hooks = jQuery._queueHooks(elem, type), next = function () {
|
||
jQuery.dequeue(elem, type)
|
||
};
|
||
// If the fx queue is dequeued, always remove the progress sentinel
|
||
if (fn === 'inprogress') {
|
||
fn = queue.shift();
|
||
startLength--
|
||
}
|
||
if (fn) {
|
||
// Add a progress sentinel to prevent the fx queue from being
|
||
// automatically dequeued
|
||
if (type === 'fx') {
|
||
queue.unshift('inprogress')
|
||
}
|
||
// Clear up the last queue stop function
|
||
delete hooks.stop;
|
||
fn.call(elem, next, hooks)
|
||
}
|
||
if (!startLength && hooks) {
|
||
hooks.empty.fire()
|
||
}
|
||
},
|
||
// Not public - generate a queueHooks object, or return the current one
|
||
_queueHooks: function (elem, type) {
|
||
var key = type + 'queueHooks';
|
||
return dataPriv.get(elem, key) || dataPriv.access(elem, key, {
|
||
empty: jQuery.Callbacks('once memory').add(function () {
|
||
dataPriv.remove(elem, [
|
||
type + 'queue',
|
||
key
|
||
])
|
||
})
|
||
})
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
queue: function (type, data) {
|
||
var setter = 2;
|
||
if (typeof type !== 'string') {
|
||
data = type;
|
||
type = 'fx';
|
||
setter--
|
||
}
|
||
if (arguments.length < setter) {
|
||
return jQuery.queue(this[0], type)
|
||
}
|
||
return data === undefined ? this : this.each(function () {
|
||
var queue = jQuery.queue(this, type, data);
|
||
// Ensure a hooks for this queue
|
||
jQuery._queueHooks(this, type);
|
||
if (type === 'fx' && queue[0] !== 'inprogress') {
|
||
jQuery.dequeue(this, type)
|
||
}
|
||
})
|
||
},
|
||
dequeue: function (type) {
|
||
return this.each(function () {
|
||
jQuery.dequeue(this, type)
|
||
})
|
||
},
|
||
clearQueue: function (type) {
|
||
return this.queue(type || 'fx', [])
|
||
},
|
||
// Get a promise resolved when queues of a certain type
|
||
// are emptied (fx is the type by default)
|
||
promise: function (type, obj) {
|
||
var tmp, count = 1, defer = jQuery.Deferred(), elements = this, i = this.length, resolve = function () {
|
||
if (!--count) {
|
||
defer.resolveWith(elements, [elements])
|
||
}
|
||
};
|
||
if (typeof type !== 'string') {
|
||
obj = type;
|
||
type = undefined
|
||
}
|
||
type = type || 'fx';
|
||
while (i--) {
|
||
tmp = dataPriv.get(elements[i], type + 'queueHooks');
|
||
if (tmp && tmp.empty) {
|
||
count++;
|
||
tmp.empty.add(resolve)
|
||
}
|
||
}
|
||
resolve();
|
||
return defer.promise(obj)
|
||
}
|
||
});
|
||
var pnum = /[+-]?(?:\d*\.|)\d+(?:[eE][+-]?\d+|)/.source;
|
||
var rcssNum = new RegExp('^(?:([+-])=|)(' + pnum + ')([a-z%]*)$', 'i');
|
||
var cssExpand = [
|
||
'Top',
|
||
'Right',
|
||
'Bottom',
|
||
'Left'
|
||
];
|
||
var isHidden = function (elem, el) {
|
||
// isHidden might be called from jQuery#filter function;
|
||
// in that case, element will be second argument
|
||
elem = el || elem;
|
||
return jQuery.css(elem, 'display') === 'none' || !jQuery.contains(elem.ownerDocument, elem)
|
||
};
|
||
function adjustCSS(elem, prop, valueParts, tween) {
|
||
var adjusted, scale = 1, maxIterations = 20, currentValue = tween ? function () {
|
||
return tween.cur()
|
||
} : function () {
|
||
return jQuery.css(elem, prop, '')
|
||
}, initial = currentValue(), unit = valueParts && valueParts[3] || (jQuery.cssNumber[prop] ? '' : 'px'),
|
||
// Starting value computation is required for potential unit mismatches
|
||
initialInUnit = (jQuery.cssNumber[prop] || unit !== 'px' && +initial) && rcssNum.exec(jQuery.css(elem, prop));
|
||
if (initialInUnit && initialInUnit[3] !== unit) {
|
||
// Trust units reported by jQuery.css
|
||
unit = unit || initialInUnit[3];
|
||
// Make sure we update the tween properties later on
|
||
valueParts = valueParts || [];
|
||
// Iteratively approximate from a nonzero starting point
|
||
initialInUnit = +initial || 1;
|
||
do {
|
||
// If previous iteration zeroed out, double until we get *something*.
|
||
// Use string for doubling so we don't accidentally see scale as unchanged below
|
||
scale = scale || '.5';
|
||
// Adjust and apply
|
||
initialInUnit = initialInUnit / scale;
|
||
jQuery.style(elem, prop, initialInUnit + unit) // Update scale, tolerating zero or NaN from tween.cur()
|
||
// Break the loop if scale is unchanged or perfect, or if we've just had enough.
|
||
} while (scale !== (scale = currentValue() / initial) && scale !== 1 && --maxIterations)
|
||
}
|
||
if (valueParts) {
|
||
initialInUnit = +initialInUnit || +initial || 0;
|
||
// Apply relative offset (+=/-=) if specified
|
||
adjusted = valueParts[1] ? initialInUnit + (valueParts[1] + 1) * valueParts[2] : +valueParts[2];
|
||
if (tween) {
|
||
tween.unit = unit;
|
||
tween.start = initialInUnit;
|
||
tween.end = adjusted
|
||
}
|
||
}
|
||
return adjusted
|
||
}
|
||
var rcheckableType = /^(?:checkbox|radio)$/i;
|
||
var rtagName = /<([\w:-]+)/;
|
||
var rscriptType = /^$|\/(?:java|ecma)script/i;
|
||
// We have to close these tags to support XHTML (#13200)
|
||
var wrapMap = {
|
||
// Support: IE9
|
||
option: [
|
||
1,
|
||
"<select multiple='multiple'>",
|
||
'</select>'
|
||
],
|
||
// XHTML parsers do not magically insert elements in the
|
||
// same way that tag soup parsers do. So we cannot shorten
|
||
// this by omitting <tbody> or other required elements.
|
||
thead: [
|
||
1,
|
||
'<table>',
|
||
'</table>'
|
||
],
|
||
col: [
|
||
2,
|
||
'<table><colgroup>',
|
||
'</colgroup></table>'
|
||
],
|
||
tr: [
|
||
2,
|
||
'<table><tbody>',
|
||
'</tbody></table>'
|
||
],
|
||
td: [
|
||
3,
|
||
'<table><tbody><tr>',
|
||
'</tr></tbody></table>'
|
||
],
|
||
_default: [
|
||
0,
|
||
'',
|
||
''
|
||
]
|
||
};
|
||
// Support: IE9
|
||
wrapMap.optgroup = wrapMap.option;
|
||
wrapMap.tbody = wrapMap.tfoot = wrapMap.colgroup = wrapMap.caption = wrapMap.thead;
|
||
wrapMap.th = wrapMap.td;
|
||
function getAll(context, tag) {
|
||
// Support: IE9-11+
|
||
// Use typeof to avoid zero-argument method invocation on host objects (#15151)
|
||
var ret = typeof context.getElementsByTagName !== 'undefined' ? context.getElementsByTagName(tag || '*') : typeof context.querySelectorAll !== 'undefined' ? context.querySelectorAll(tag || '*') : [];
|
||
return tag === undefined || tag && jQuery.nodeName(context, tag) ? jQuery.merge([context], ret) : ret
|
||
}
|
||
// Mark scripts as having already been evaluated
|
||
function setGlobalEval(elems, refElements) {
|
||
var i = 0, l = elems.length;
|
||
for (; i < l; i++) {
|
||
dataPriv.set(elems[i], 'globalEval', !refElements || dataPriv.get(refElements[i], 'globalEval'))
|
||
}
|
||
}
|
||
var rhtml = /<|&#?\w+;/;
|
||
function buildFragment(elems, context, scripts, selection, ignored) {
|
||
var elem, tmp, tag, wrap, contains, j, fragment = context.createDocumentFragment(), nodes = [], i = 0, l = elems.length;
|
||
for (; i < l; i++) {
|
||
elem = elems[i];
|
||
if (elem || elem === 0) {
|
||
// Add nodes directly
|
||
if (jQuery.type(elem) === 'object') {
|
||
// Support: Android<4.1, PhantomJS<2
|
||
// push.apply(_, arraylike) throws on ancient WebKit
|
||
jQuery.merge(nodes, elem.nodeType ? [elem] : elem) // Convert non-html into a text node
|
||
} else if (!rhtml.test(elem)) {
|
||
nodes.push(context.createTextNode(elem)) // Convert html into DOM nodes
|
||
} else {
|
||
tmp = tmp || fragment.appendChild(context.createElement('div'));
|
||
// Deserialize a standard representation
|
||
tag = (rtagName.exec(elem) || [
|
||
'',
|
||
''
|
||
])[1].toLowerCase();
|
||
wrap = wrapMap[tag] || wrapMap._default;
|
||
tmp.innerHTML = wrap[1] + jQuery.htmlPrefilter(elem) + wrap[2];
|
||
// Descend through wrappers to the right content
|
||
j = wrap[0];
|
||
while (j--) {
|
||
tmp = tmp.lastChild
|
||
}
|
||
// Support: Android<4.1, PhantomJS<2
|
||
// push.apply(_, arraylike) throws on ancient WebKit
|
||
jQuery.merge(nodes, tmp.childNodes);
|
||
// Remember the top-level container
|
||
tmp = fragment.firstChild;
|
||
// Ensure the created nodes are orphaned (#12392)
|
||
tmp.textContent = ''
|
||
}
|
||
}
|
||
}
|
||
// Remove wrapper from fragment
|
||
fragment.textContent = '';
|
||
i = 0;
|
||
while (elem = nodes[i++]) {
|
||
// Skip elements already in the context collection (trac-4087)
|
||
if (selection && jQuery.inArray(elem, selection) > -1) {
|
||
if (ignored) {
|
||
ignored.push(elem)
|
||
}
|
||
continue
|
||
}
|
||
contains = jQuery.contains(elem.ownerDocument, elem);
|
||
// Append to fragment
|
||
tmp = getAll(fragment.appendChild(elem), 'script');
|
||
// Preserve script evaluation history
|
||
if (contains) {
|
||
setGlobalEval(tmp)
|
||
}
|
||
// Capture executables
|
||
if (scripts) {
|
||
j = 0;
|
||
while (elem = tmp[j++]) {
|
||
if (rscriptType.test(elem.type || '')) {
|
||
scripts.push(elem)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return fragment
|
||
}
|
||
(function () {
|
||
var fragment = document.createDocumentFragment(), div = fragment.appendChild(document.createElement('div')), input = document.createElement('input');
|
||
// Support: Android 4.0-4.3, Safari<=5.1
|
||
// Check state lost if the name is set (#11217)
|
||
// Support: Windows Web Apps (WWA)
|
||
// `name` and `type` must use .setAttribute for WWA (#14901)
|
||
input.setAttribute('type', 'radio');
|
||
input.setAttribute('checked', 'checked');
|
||
input.setAttribute('name', 't');
|
||
div.appendChild(input);
|
||
// Support: Safari<=5.1, Android<4.2
|
||
// Older WebKit doesn't clone checked state correctly in fragments
|
||
support.checkClone = div.cloneNode(true).cloneNode(true).lastChild.checked;
|
||
// Support: IE<=11+
|
||
// Make sure textarea (and checkbox) defaultValue is properly cloned
|
||
div.innerHTML = '<textarea>x</textarea>';
|
||
support.noCloneChecked = !!div.cloneNode(true).lastChild.defaultValue
|
||
}());
|
||
var rkeyEvent = /^key/, rmouseEvent = /^(?:mouse|pointer|contextmenu|drag|drop)|click/, rtypenamespace = /^([^.]*)(?:\.(.+)|)/;
|
||
function returnTrue() {
|
||
return true
|
||
}
|
||
function returnFalse() {
|
||
return false
|
||
}
|
||
// Support: IE9
|
||
// See #13393 for more info
|
||
function safeActiveElement() {
|
||
try {
|
||
return document.activeElement
|
||
} catch (err) {
|
||
}
|
||
}
|
||
function on(elem, types, selector, data, fn, one) {
|
||
var origFn, type;
|
||
// Types can be a map of types/handlers
|
||
if (typeof types === 'object') {
|
||
// ( types-Object, selector, data )
|
||
if (typeof selector !== 'string') {
|
||
// ( types-Object, data )
|
||
data = data || selector;
|
||
selector = undefined
|
||
}
|
||
for (type in types) {
|
||
on(elem, type, selector, data, types[type], one)
|
||
}
|
||
return elem
|
||
}
|
||
if (data == null && fn == null) {
|
||
// ( types, fn )
|
||
fn = selector;
|
||
data = selector = undefined
|
||
} else if (fn == null) {
|
||
if (typeof selector === 'string') {
|
||
// ( types, selector, fn )
|
||
fn = data;
|
||
data = undefined
|
||
} else {
|
||
// ( types, data, fn )
|
||
fn = data;
|
||
data = selector;
|
||
selector = undefined
|
||
}
|
||
}
|
||
if (fn === false) {
|
||
fn = returnFalse
|
||
} else if (!fn) {
|
||
return elem
|
||
}
|
||
if (one === 1) {
|
||
origFn = fn;
|
||
fn = function (event) {
|
||
// Can use an empty set, since event contains the info
|
||
jQuery().off(event);
|
||
return origFn.apply(this, arguments)
|
||
};
|
||
// Use same guid so caller can remove using origFn
|
||
fn.guid = origFn.guid || (origFn.guid = jQuery.guid++)
|
||
}
|
||
return elem.each(function () {
|
||
jQuery.event.add(this, types, fn, data, selector)
|
||
})
|
||
}
|
||
/*
|
||
* Helper functions for managing events -- not part of the public interface.
|
||
* Props to Dean Edwards' addEvent library for many of the ideas.
|
||
*/
|
||
jQuery.event = {
|
||
global: {},
|
||
add: function (elem, types, handler, data, selector) {
|
||
var handleObjIn, eventHandle, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.get(elem);
|
||
// Don't attach events to noData or text/comment nodes (but allow plain objects)
|
||
if (!elemData) {
|
||
return
|
||
}
|
||
// Caller can pass in an object of custom data in lieu of the handler
|
||
if (handler.handler) {
|
||
handleObjIn = handler;
|
||
handler = handleObjIn.handler;
|
||
selector = handleObjIn.selector
|
||
}
|
||
// Make sure that the handler has a unique ID, used to find/remove it later
|
||
if (!handler.guid) {
|
||
handler.guid = jQuery.guid++
|
||
}
|
||
// Init the element's event structure and main handler, if this is the first
|
||
if (!(events = elemData.events)) {
|
||
events = elemData.events = {}
|
||
}
|
||
if (!(eventHandle = elemData.handle)) {
|
||
eventHandle = elemData.handle = function (e) {
|
||
// Discard the second event of a jQuery.event.trigger() and
|
||
// when an event is called after a page has unloaded
|
||
return typeof jQuery !== 'undefined' && jQuery.event.triggered !== e.type ? jQuery.event.dispatch.apply(elem, arguments) : undefined
|
||
}
|
||
}
|
||
// Handle multiple events separated by a space
|
||
types = (types || '').match(rnotwhite) || [''];
|
||
t = types.length;
|
||
while (t--) {
|
||
tmp = rtypenamespace.exec(types[t]) || [];
|
||
type = origType = tmp[1];
|
||
namespaces = (tmp[2] || '').split('.').sort();
|
||
// There *must* be a type, no attaching namespace-only handlers
|
||
if (!type) {
|
||
continue
|
||
}
|
||
// If event changes its type, use the special event handlers for the changed type
|
||
special = jQuery.event.special[type] || {};
|
||
// If selector defined, determine special event api type, otherwise given type
|
||
type = (selector ? special.delegateType : special.bindType) || type;
|
||
// Update special based on newly reset type
|
||
special = jQuery.event.special[type] || {};
|
||
// handleObj is passed to all event handlers
|
||
handleObj = jQuery.extend({
|
||
type: type,
|
||
origType: origType,
|
||
data: data,
|
||
handler: handler,
|
||
guid: handler.guid,
|
||
selector: selector,
|
||
needsContext: selector && jQuery.expr.match.needsContext.test(selector),
|
||
namespace: namespaces.join('.')
|
||
}, handleObjIn);
|
||
// Init the event handler queue if we're the first
|
||
if (!(handlers = events[type])) {
|
||
handlers = events[type] = [];
|
||
handlers.delegateCount = 0;
|
||
// Only use addEventListener if the special events handler returns false
|
||
if (!special.setup || special.setup.call(elem, data, namespaces, eventHandle) === false) {
|
||
if (elem.addEventListener) {
|
||
elem.addEventListener(type, eventHandle)
|
||
}
|
||
}
|
||
}
|
||
if (special.add) {
|
||
special.add.call(elem, handleObj);
|
||
if (!handleObj.handler.guid) {
|
||
handleObj.handler.guid = handler.guid
|
||
}
|
||
}
|
||
// Add to the element's handler list, delegates in front
|
||
if (selector) {
|
||
handlers.splice(handlers.delegateCount++, 0, handleObj)
|
||
} else {
|
||
handlers.push(handleObj)
|
||
}
|
||
// Keep track of which events have ever been used, for event optimization
|
||
jQuery.event.global[type] = true
|
||
}
|
||
},
|
||
// Detach an event or set of events from an element
|
||
remove: function (elem, types, handler, selector, mappedTypes) {
|
||
var j, origCount, tmp, events, t, handleObj, special, handlers, type, namespaces, origType, elemData = dataPriv.hasData(elem) && dataPriv.get(elem);
|
||
if (!elemData || !(events = elemData.events)) {
|
||
return
|
||
}
|
||
// Once for each type.namespace in types; type may be omitted
|
||
types = (types || '').match(rnotwhite) || [''];
|
||
t = types.length;
|
||
while (t--) {
|
||
tmp = rtypenamespace.exec(types[t]) || [];
|
||
type = origType = tmp[1];
|
||
namespaces = (tmp[2] || '').split('.').sort();
|
||
// Unbind all events (on this namespace, if provided) for the element
|
||
if (!type) {
|
||
for (type in events) {
|
||
jQuery.event.remove(elem, type + types[t], handler, selector, true)
|
||
}
|
||
continue
|
||
}
|
||
special = jQuery.event.special[type] || {};
|
||
type = (selector ? special.delegateType : special.bindType) || type;
|
||
handlers = events[type] || [];
|
||
tmp = tmp[2] && new RegExp('(^|\\.)' + namespaces.join('\\.(?:.*\\.|)') + '(\\.|$)');
|
||
// Remove matching events
|
||
origCount = j = handlers.length;
|
||
while (j--) {
|
||
handleObj = handlers[j];
|
||
if ((mappedTypes || origType === handleObj.origType) && (!handler || handler.guid === handleObj.guid) && (!tmp || tmp.test(handleObj.namespace)) && (!selector || selector === handleObj.selector || selector === '**' && handleObj.selector)) {
|
||
handlers.splice(j, 1);
|
||
if (handleObj.selector) {
|
||
handlers.delegateCount--
|
||
}
|
||
if (special.remove) {
|
||
special.remove.call(elem, handleObj)
|
||
}
|
||
}
|
||
}
|
||
// Remove generic event handler if we removed something and no more handlers exist
|
||
// (avoids potential for endless recursion during removal of special event handlers)
|
||
if (origCount && !handlers.length) {
|
||
if (!special.teardown || special.teardown.call(elem, namespaces, elemData.handle) === false) {
|
||
jQuery.removeEvent(elem, type, elemData.handle)
|
||
}
|
||
delete events[type]
|
||
}
|
||
}
|
||
// Remove data and the expando if it's no longer used
|
||
if (jQuery.isEmptyObject(events)) {
|
||
dataPriv.remove(elem, 'handle events')
|
||
}
|
||
},
|
||
dispatch: function (event) {
|
||
// Make a writable jQuery.Event from the native event object
|
||
event = jQuery.event.fix(event);
|
||
var i, j, ret, matched, handleObj, handlerQueue = [], args = slice.call(arguments), handlers = (dataPriv.get(this, 'events') || {})[event.type] || [], special = jQuery.event.special[event.type] || {};
|
||
// Use the fix-ed jQuery.Event rather than the (read-only) native event
|
||
args[0] = event;
|
||
event.delegateTarget = this;
|
||
// Call the preDispatch hook for the mapped type, and let it bail if desired
|
||
if (special.preDispatch && special.preDispatch.call(this, event) === false) {
|
||
return
|
||
}
|
||
// Determine handlers
|
||
handlerQueue = jQuery.event.handlers.call(this, event, handlers);
|
||
// Run delegates first; they may want to stop propagation beneath us
|
||
i = 0;
|
||
while ((matched = handlerQueue[i++]) && !event.isPropagationStopped()) {
|
||
event.currentTarget = matched.elem;
|
||
j = 0;
|
||
while ((handleObj = matched.handlers[j++]) && !event.isImmediatePropagationStopped()) {
|
||
// Triggered event must either 1) have no namespace, or 2) have namespace(s)
|
||
// a subset or equal to those in the bound event (both can have no namespace).
|
||
if (!event.rnamespace || event.rnamespace.test(handleObj.namespace)) {
|
||
event.handleObj = handleObj;
|
||
event.data = handleObj.data;
|
||
ret = ((jQuery.event.special[handleObj.origType] || {}).handle || handleObj.handler).apply(matched.elem, args);
|
||
if (ret !== undefined) {
|
||
if ((event.result = ret) === false) {
|
||
event.preventDefault();
|
||
event.stopPropagation()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Call the postDispatch hook for the mapped type
|
||
if (special.postDispatch) {
|
||
special.postDispatch.call(this, event)
|
||
}
|
||
return event.result
|
||
},
|
||
handlers: function (event, handlers) {
|
||
var i, matches, sel, handleObj, handlerQueue = [], delegateCount = handlers.delegateCount, cur = event.target;
|
||
// Support (at least): Chrome, IE9
|
||
// Find delegate handlers
|
||
// Black-hole SVG <use> instance trees (#13180)
|
||
//
|
||
// Support: Firefox<=42+
|
||
// Avoid non-left-click in FF but don't block IE radio events (#3861, gh-2343)
|
||
if (delegateCount && cur.nodeType && (event.type !== 'click' || isNaN(event.button) || event.button < 1)) {
|
||
for (; cur !== this; cur = cur.parentNode || this) {
|
||
// Don't check non-elements (#13208)
|
||
// Don't process clicks on disabled elements (#6911, #8165, #11382, #11764)
|
||
if (cur.nodeType === 1 && (cur.disabled !== true || event.type !== 'click')) {
|
||
matches = [];
|
||
for (i = 0; i < delegateCount; i++) {
|
||
handleObj = handlers[i];
|
||
// Don't conflict with Object.prototype properties (#13203)
|
||
sel = handleObj.selector + ' ';
|
||
if (matches[sel] === undefined) {
|
||
matches[sel] = handleObj.needsContext ? jQuery(sel, this).index(cur) > -1 : jQuery.find(sel, this, null, [cur]).length
|
||
}
|
||
if (matches[sel]) {
|
||
matches.push(handleObj)
|
||
}
|
||
}
|
||
if (matches.length) {
|
||
handlerQueue.push({
|
||
elem: cur,
|
||
handlers: matches
|
||
})
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Add the remaining (directly-bound) handlers
|
||
if (delegateCount < handlers.length) {
|
||
handlerQueue.push({
|
||
elem: this,
|
||
handlers: handlers.slice(delegateCount)
|
||
})
|
||
}
|
||
return handlerQueue
|
||
},
|
||
// Includes some event props shared by KeyEvent and MouseEvent
|
||
props: ('altKey bubbles cancelable ctrlKey currentTarget detail eventPhase ' + 'metaKey relatedTarget shiftKey target timeStamp view which').split(' '),
|
||
fixHooks: {},
|
||
keyHooks: {
|
||
props: 'char charCode key keyCode'.split(' '),
|
||
filter: function (event, original) {
|
||
// Add which for key events
|
||
if (event.which == null) {
|
||
event.which = original.charCode != null ? original.charCode : original.keyCode
|
||
}
|
||
return event
|
||
}
|
||
},
|
||
mouseHooks: {
|
||
props: ('button buttons clientX clientY offsetX offsetY pageX pageY ' + 'screenX screenY toElement').split(' '),
|
||
filter: function (event, original) {
|
||
var eventDoc, doc, body, button = original.button;
|
||
// Calculate pageX/Y if missing and clientX/Y available
|
||
if (event.pageX == null && original.clientX != null) {
|
||
eventDoc = event.target.ownerDocument || document;
|
||
doc = eventDoc.documentElement;
|
||
body = eventDoc.body;
|
||
event.pageX = original.clientX + (doc && doc.scrollLeft || body && body.scrollLeft || 0) - (doc && doc.clientLeft || body && body.clientLeft || 0);
|
||
event.pageY = original.clientY + (doc && doc.scrollTop || body && body.scrollTop || 0) - (doc && doc.clientTop || body && body.clientTop || 0)
|
||
}
|
||
// Add which for click: 1 === left; 2 === middle; 3 === right
|
||
// Note: button is not normalized, so don't use it
|
||
if (!event.which && button !== undefined) {
|
||
event.which = button & 1 ? 1 : button & 2 ? 3 : button & 4 ? 2 : 0
|
||
}
|
||
return event
|
||
}
|
||
},
|
||
fix: function (event) {
|
||
if (event[jQuery.expando]) {
|
||
return event
|
||
}
|
||
// Create a writable copy of the event object and normalize some properties
|
||
var i, prop, copy, type = event.type, originalEvent = event, fixHook = this.fixHooks[type];
|
||
if (!fixHook) {
|
||
this.fixHooks[type] = fixHook = rmouseEvent.test(type) ? this.mouseHooks : rkeyEvent.test(type) ? this.keyHooks : {}
|
||
}
|
||
copy = fixHook.props ? this.props.concat(fixHook.props) : this.props;
|
||
event = new jQuery.Event(originalEvent);
|
||
i = copy.length;
|
||
while (i--) {
|
||
prop = copy[i];
|
||
event[prop] = originalEvent[prop]
|
||
}
|
||
// Support: Cordova 2.5 (WebKit) (#13255)
|
||
// All events should have a target; Cordova deviceready doesn't
|
||
if (!event.target) {
|
||
event.target = document
|
||
}
|
||
// Support: Safari 6.0+, Chrome<28
|
||
// Target should not be a text node (#504, #13143)
|
||
if (event.target.nodeType === 3) {
|
||
event.target = event.target.parentNode
|
||
}
|
||
return fixHook.filter ? fixHook.filter(event, originalEvent) : event
|
||
},
|
||
special: {
|
||
load: {
|
||
// Prevent triggered image.load events from bubbling to window.load
|
||
noBubble: true
|
||
},
|
||
focus: {
|
||
// Fire native event if possible so blur/focus sequence is correct
|
||
trigger: function () {
|
||
if (this !== safeActiveElement() && this.focus) {
|
||
this.focus();
|
||
return false
|
||
}
|
||
},
|
||
delegateType: 'focusin'
|
||
},
|
||
blur: {
|
||
trigger: function () {
|
||
if (this === safeActiveElement() && this.blur) {
|
||
this.blur();
|
||
return false
|
||
}
|
||
},
|
||
delegateType: 'focusout'
|
||
},
|
||
click: {
|
||
// For checkbox, fire native event so checked state will be right
|
||
trigger: function () {
|
||
if (this.type === 'checkbox' && this.click && jQuery.nodeName(this, 'input')) {
|
||
this.click();
|
||
return false
|
||
}
|
||
},
|
||
// For cross-browser consistency, don't fire native .click() on links
|
||
_default: function (event) {
|
||
return jQuery.nodeName(event.target, 'a')
|
||
}
|
||
},
|
||
beforeunload: {
|
||
postDispatch: function (event) {
|
||
// Support: Firefox 20+
|
||
// Firefox doesn't alert if the returnValue field is not set.
|
||
if (event.result !== undefined && event.originalEvent) {
|
||
event.originalEvent.returnValue = event.result
|
||
}
|
||
}
|
||
}
|
||
}
|
||
};
|
||
jQuery.removeEvent = function (elem, type, handle) {
|
||
// This "if" is needed for plain objects
|
||
if (elem.removeEventListener) {
|
||
elem.removeEventListener(type, handle)
|
||
}
|
||
};
|
||
jQuery.Event = function (src, props) {
|
||
// Allow instantiation without the 'new' keyword
|
||
if (!(this instanceof jQuery.Event)) {
|
||
return new jQuery.Event(src, props)
|
||
}
|
||
// Event object
|
||
if (src && src.type) {
|
||
this.originalEvent = src;
|
||
this.type = src.type;
|
||
// Events bubbling up the document may have been marked as prevented
|
||
// by a handler lower down the tree; reflect the correct value.
|
||
this.isDefaultPrevented = src.defaultPrevented || src.defaultPrevented === undefined && // Support: Android<4.0
|
||
src.returnValue === false ? returnTrue : returnFalse // Event type
|
||
} else {
|
||
this.type = src
|
||
}
|
||
// Put explicitly provided properties onto the event object
|
||
if (props) {
|
||
jQuery.extend(this, props)
|
||
}
|
||
// Create a timestamp if incoming event doesn't have one
|
||
this.timeStamp = src && src.timeStamp || jQuery.now();
|
||
// Mark it as fixed
|
||
this[jQuery.expando] = true
|
||
};
|
||
// jQuery.Event is based on DOM3 Events as specified by the ECMAScript Language Binding
|
||
// http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/ecma-script-binding.html
|
||
jQuery.Event.prototype = {
|
||
constructor: jQuery.Event,
|
||
isDefaultPrevented: returnFalse,
|
||
isPropagationStopped: returnFalse,
|
||
isImmediatePropagationStopped: returnFalse,
|
||
preventDefault: function () {
|
||
var e = this.originalEvent;
|
||
this.isDefaultPrevented = returnTrue;
|
||
if (e) {
|
||
e.preventDefault()
|
||
}
|
||
},
|
||
stopPropagation: function () {
|
||
var e = this.originalEvent;
|
||
this.isPropagationStopped = returnTrue;
|
||
if (e) {
|
||
e.stopPropagation()
|
||
}
|
||
},
|
||
stopImmediatePropagation: function () {
|
||
var e = this.originalEvent;
|
||
this.isImmediatePropagationStopped = returnTrue;
|
||
if (e) {
|
||
e.stopImmediatePropagation()
|
||
}
|
||
this.stopPropagation()
|
||
}
|
||
};
|
||
// Create mouseenter/leave events using mouseover/out and event-time checks
|
||
// so that event delegation works in jQuery.
|
||
// Do the same for pointerenter/pointerleave and pointerover/pointerout
|
||
//
|
||
// Support: Safari 7 only
|
||
// Safari sends mouseenter too often; see:
|
||
// https://code.google.com/p/chromium/issues/detail?id=470258
|
||
// for the description of the bug (it existed in older Chrome versions as well).
|
||
jQuery.each({
|
||
mouseenter: 'mouseover',
|
||
mouseleave: 'mouseout',
|
||
pointerenter: 'pointerover',
|
||
pointerleave: 'pointerout'
|
||
}, function (orig, fix) {
|
||
jQuery.event.special[orig] = {
|
||
delegateType: fix,
|
||
bindType: fix,
|
||
handle: function (event) {
|
||
var ret, target = this, related = event.relatedTarget, handleObj = event.handleObj;
|
||
// For mouseenter/leave call the handler if related is outside the target.
|
||
// NB: No relatedTarget if the mouse left/entered the browser window
|
||
if (!related || related !== target && !jQuery.contains(target, related)) {
|
||
event.type = handleObj.origType;
|
||
ret = handleObj.handler.apply(this, arguments);
|
||
event.type = fix
|
||
}
|
||
return ret
|
||
}
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
on: function (types, selector, data, fn) {
|
||
return on(this, types, selector, data, fn)
|
||
},
|
||
one: function (types, selector, data, fn) {
|
||
return on(this, types, selector, data, fn, 1)
|
||
},
|
||
off: function (types, selector, fn) {
|
||
var handleObj, type;
|
||
if (types && types.preventDefault && types.handleObj) {
|
||
// ( event ) dispatched jQuery.Event
|
||
handleObj = types.handleObj;
|
||
jQuery(types.delegateTarget).off(handleObj.namespace ? handleObj.origType + '.' + handleObj.namespace : handleObj.origType, handleObj.selector, handleObj.handler);
|
||
return this
|
||
}
|
||
if (typeof types === 'object') {
|
||
// ( types-object [, selector] )
|
||
for (type in types) {
|
||
this.off(type, selector, types[type])
|
||
}
|
||
return this
|
||
}
|
||
if (selector === false || typeof selector === 'function') {
|
||
// ( types [, fn] )
|
||
fn = selector;
|
||
selector = undefined
|
||
}
|
||
if (fn === false) {
|
||
fn = returnFalse
|
||
}
|
||
return this.each(function () {
|
||
jQuery.event.remove(this, types, fn, selector)
|
||
})
|
||
}
|
||
});
|
||
var rxhtmlTag = /<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:-]+)[^>]*)\/>/gi,
|
||
// Support: IE 10-11, Edge 10240+
|
||
// In IE/Edge using regex groups here causes severe slowdowns.
|
||
// See https://connect.microsoft.com/IE/feedback/details/1736512/
|
||
rnoInnerhtml = /<script|<style|<link/i,
|
||
// checked="checked" or checked
|
||
rchecked = /checked\s*(?:[^=]|=\s*.checked.)/i, rscriptTypeMasked = /^true\/(.*)/, rcleanScript = /^\s*<!(?:\[CDATA\[|--)|(?:\]\]|--)>\s*$/g;
|
||
// Manipulating tables requires a tbody
|
||
function manipulationTarget(elem, content) {
|
||
return jQuery.nodeName(elem, 'table') && jQuery.nodeName(content.nodeType !== 11 ? content : content.firstChild, 'tr') ? elem.getElementsByTagName('tbody')[0] || elem.appendChild(elem.ownerDocument.createElement('tbody')) : elem
|
||
}
|
||
// Replace/restore the type attribute of script elements for safe DOM manipulation
|
||
function disableScript(elem) {
|
||
elem.type = (elem.getAttribute('type') !== null) + '/' + elem.type;
|
||
return elem
|
||
}
|
||
function restoreScript(elem) {
|
||
var match = rscriptTypeMasked.exec(elem.type);
|
||
if (match) {
|
||
elem.type = match[1]
|
||
} else {
|
||
elem.removeAttribute('type')
|
||
}
|
||
return elem
|
||
}
|
||
function cloneCopyEvent(src, dest) {
|
||
var i, l, type, pdataOld, pdataCur, udataOld, udataCur, events;
|
||
if (dest.nodeType !== 1) {
|
||
return
|
||
}
|
||
// 1. Copy private data: events, handlers, etc.
|
||
if (dataPriv.hasData(src)) {
|
||
pdataOld = dataPriv.access(src);
|
||
pdataCur = dataPriv.set(dest, pdataOld);
|
||
events = pdataOld.events;
|
||
if (events) {
|
||
delete pdataCur.handle;
|
||
pdataCur.events = {};
|
||
for (type in events) {
|
||
for (i = 0, l = events[type].length; i < l; i++) {
|
||
jQuery.event.add(dest, type, events[type][i])
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// 2. Copy user data
|
||
if (dataUser.hasData(src)) {
|
||
udataOld = dataUser.access(src);
|
||
udataCur = jQuery.extend({}, udataOld);
|
||
dataUser.set(dest, udataCur)
|
||
}
|
||
}
|
||
// Fix IE bugs, see support tests
|
||
function fixInput(src, dest) {
|
||
var nodeName = dest.nodeName.toLowerCase();
|
||
// Fails to persist the checked state of a cloned checkbox or radio button.
|
||
if (nodeName === 'input' && rcheckableType.test(src.type)) {
|
||
dest.checked = src.checked // Fails to return the selected option to the default selected state when cloning options
|
||
} else if (nodeName === 'input' || nodeName === 'textarea') {
|
||
dest.defaultValue = src.defaultValue
|
||
}
|
||
}
|
||
function domManip(collection, args, callback, ignored) {
|
||
// Flatten any nested arrays
|
||
args = concat.apply([], args);
|
||
var fragment, first, scripts, hasScripts, node, doc, i = 0, l = collection.length, iNoClone = l - 1, value = args[0], isFunction = jQuery.isFunction(value);
|
||
// We can't cloneNode fragments that contain checked, in WebKit
|
||
if (isFunction || l > 1 && typeof value === 'string' && !support.checkClone && rchecked.test(value)) {
|
||
return collection.each(function (index) {
|
||
var self = collection.eq(index);
|
||
if (isFunction) {
|
||
args[0] = value.call(this, index, self.html())
|
||
}
|
||
domManip(self, args, callback, ignored)
|
||
})
|
||
}
|
||
if (l) {
|
||
fragment = buildFragment(args, collection[0].ownerDocument, false, collection, ignored);
|
||
first = fragment.firstChild;
|
||
if (fragment.childNodes.length === 1) {
|
||
fragment = first
|
||
}
|
||
// Require either new content or an interest in ignored elements to invoke the callback
|
||
if (first || ignored) {
|
||
scripts = jQuery.map(getAll(fragment, 'script'), disableScript);
|
||
hasScripts = scripts.length;
|
||
// Use the original fragment for the last item
|
||
// instead of the first because it can end up
|
||
// being emptied incorrectly in certain situations (#8070).
|
||
for (; i < l; i++) {
|
||
node = fragment;
|
||
if (i !== iNoClone) {
|
||
node = jQuery.clone(node, true, true);
|
||
// Keep references to cloned scripts for later restoration
|
||
if (hasScripts) {
|
||
// Support: Android<4.1, PhantomJS<2
|
||
// push.apply(_, arraylike) throws on ancient WebKit
|
||
jQuery.merge(scripts, getAll(node, 'script'))
|
||
}
|
||
}
|
||
callback.call(collection[i], node, i)
|
||
}
|
||
if (hasScripts) {
|
||
doc = scripts[scripts.length - 1].ownerDocument;
|
||
// Reenable scripts
|
||
jQuery.map(scripts, restoreScript);
|
||
// Evaluate executable scripts on first document insertion
|
||
for (i = 0; i < hasScripts; i++) {
|
||
node = scripts[i];
|
||
if (rscriptType.test(node.type || '') && !dataPriv.access(node, 'globalEval') && jQuery.contains(doc, node)) {
|
||
if (node.src) {
|
||
// Optional AJAX dependency, but won't run scripts if not present
|
||
if (jQuery._evalUrl) {
|
||
jQuery._evalUrl(node.src)
|
||
}
|
||
} else {
|
||
jQuery.globalEval(node.textContent.replace(rcleanScript, ''))
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return collection
|
||
}
|
||
function remove(elem, selector, keepData) {
|
||
var node, nodes = selector ? jQuery.filter(selector, elem) : elem, i = 0;
|
||
for (; (node = nodes[i]) != null; i++) {
|
||
if (!keepData && node.nodeType === 1) {
|
||
jQuery.cleanData(getAll(node))
|
||
}
|
||
if (node.parentNode) {
|
||
if (keepData && jQuery.contains(node.ownerDocument, node)) {
|
||
setGlobalEval(getAll(node, 'script'))
|
||
}
|
||
node.parentNode.removeChild(node)
|
||
}
|
||
}
|
||
return elem
|
||
}
|
||
jQuery.extend({
|
||
htmlPrefilter: function (html) {
|
||
return html.replace(rxhtmlTag, '<$1></$2>')
|
||
},
|
||
clone: function (elem, dataAndEvents, deepDataAndEvents) {
|
||
var i, l, srcElements, destElements, clone = elem.cloneNode(true), inPage = jQuery.contains(elem.ownerDocument, elem);
|
||
// Fix IE cloning issues
|
||
if (!support.noCloneChecked && (elem.nodeType === 1 || elem.nodeType === 11) && !jQuery.isXMLDoc(elem)) {
|
||
// We eschew Sizzle here for performance reasons: http://jsperf.com/getall-vs-sizzle/2
|
||
destElements = getAll(clone);
|
||
srcElements = getAll(elem);
|
||
for (i = 0, l = srcElements.length; i < l; i++) {
|
||
fixInput(srcElements[i], destElements[i])
|
||
}
|
||
}
|
||
// Copy the events from the original to the clone
|
||
if (dataAndEvents) {
|
||
if (deepDataAndEvents) {
|
||
srcElements = srcElements || getAll(elem);
|
||
destElements = destElements || getAll(clone);
|
||
for (i = 0, l = srcElements.length; i < l; i++) {
|
||
cloneCopyEvent(srcElements[i], destElements[i])
|
||
}
|
||
} else {
|
||
cloneCopyEvent(elem, clone)
|
||
}
|
||
}
|
||
// Preserve script evaluation history
|
||
destElements = getAll(clone, 'script');
|
||
if (destElements.length > 0) {
|
||
setGlobalEval(destElements, !inPage && getAll(elem, 'script'))
|
||
}
|
||
// Return the cloned set
|
||
return clone
|
||
},
|
||
cleanData: function (elems) {
|
||
var data, elem, type, special = jQuery.event.special, i = 0;
|
||
for (; (elem = elems[i]) !== undefined; i++) {
|
||
if (acceptData(elem)) {
|
||
if (data = elem[dataPriv.expando]) {
|
||
if (data.events) {
|
||
for (type in data.events) {
|
||
if (special[type]) {
|
||
jQuery.event.remove(elem, type) // This is a shortcut to avoid jQuery.event.remove's overhead
|
||
} else {
|
||
jQuery.removeEvent(elem, type, data.handle)
|
||
}
|
||
}
|
||
}
|
||
// Support: Chrome <= 35-45+
|
||
// Assign undefined instead of using delete, see Data#remove
|
||
elem[dataPriv.expando] = undefined
|
||
}
|
||
if (elem[dataUser.expando]) {
|
||
// Support: Chrome <= 35-45+
|
||
// Assign undefined instead of using delete, see Data#remove
|
||
elem[dataUser.expando] = undefined
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
// Keep domManip exposed until 3.0 (gh-2225)
|
||
domManip: domManip,
|
||
detach: function (selector) {
|
||
return remove(this, selector, true)
|
||
},
|
||
remove: function (selector) {
|
||
return remove(this, selector)
|
||
},
|
||
text: function (value) {
|
||
return access(this, function (value) {
|
||
return value === undefined ? jQuery.text(this) : this.empty().each(function () {
|
||
if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
|
||
this.textContent = value
|
||
}
|
||
})
|
||
}, null, value, arguments.length)
|
||
},
|
||
append: function () {
|
||
return domManip(this, arguments, function (elem) {
|
||
if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
|
||
var target = manipulationTarget(this, elem);
|
||
target.appendChild(elem)
|
||
}
|
||
})
|
||
},
|
||
prepend: function () {
|
||
return domManip(this, arguments, function (elem) {
|
||
if (this.nodeType === 1 || this.nodeType === 11 || this.nodeType === 9) {
|
||
var target = manipulationTarget(this, elem);
|
||
target.insertBefore(elem, target.firstChild)
|
||
}
|
||
})
|
||
},
|
||
before: function () {
|
||
return domManip(this, arguments, function (elem) {
|
||
if (this.parentNode) {
|
||
this.parentNode.insertBefore(elem, this)
|
||
}
|
||
})
|
||
},
|
||
after: function () {
|
||
return domManip(this, arguments, function (elem) {
|
||
if (this.parentNode) {
|
||
this.parentNode.insertBefore(elem, this.nextSibling)
|
||
}
|
||
})
|
||
},
|
||
empty: function () {
|
||
var elem, i = 0;
|
||
for (; (elem = this[i]) != null; i++) {
|
||
if (elem.nodeType === 1) {
|
||
// Prevent memory leaks
|
||
jQuery.cleanData(getAll(elem, false));
|
||
// Remove any remaining nodes
|
||
elem.textContent = ''
|
||
}
|
||
}
|
||
return this
|
||
},
|
||
clone: function (dataAndEvents, deepDataAndEvents) {
|
||
dataAndEvents = dataAndEvents == null ? false : dataAndEvents;
|
||
deepDataAndEvents = deepDataAndEvents == null ? dataAndEvents : deepDataAndEvents;
|
||
return this.map(function () {
|
||
return jQuery.clone(this, dataAndEvents, deepDataAndEvents)
|
||
})
|
||
},
|
||
html: function (value) {
|
||
return access(this, function (value) {
|
||
var elem = this[0] || {}, i = 0, l = this.length;
|
||
if (value === undefined && elem.nodeType === 1) {
|
||
return elem.innerHTML
|
||
}
|
||
// See if we can take a shortcut and just use innerHTML
|
||
if (typeof value === 'string' && !rnoInnerhtml.test(value) && !wrapMap[(rtagName.exec(value) || [
|
||
'',
|
||
''
|
||
])[1].toLowerCase()]) {
|
||
value = jQuery.htmlPrefilter(value);
|
||
try {
|
||
for (; i < l; i++) {
|
||
elem = this[i] || {};
|
||
// Remove element nodes and prevent memory leaks
|
||
if (elem.nodeType === 1) {
|
||
jQuery.cleanData(getAll(elem, false));
|
||
elem.innerHTML = value
|
||
}
|
||
}
|
||
elem = 0 // If using innerHTML throws an exception, use the fallback method
|
||
} catch (e) {
|
||
}
|
||
}
|
||
if (elem) {
|
||
this.empty().append(value)
|
||
}
|
||
}, null, value, arguments.length)
|
||
},
|
||
replaceWith: function () {
|
||
var ignored = [];
|
||
// Make the changes, replacing each non-ignored context element with the new content
|
||
return domManip(this, arguments, function (elem) {
|
||
var parent = this.parentNode;
|
||
if (jQuery.inArray(this, ignored) < 0) {
|
||
jQuery.cleanData(getAll(this));
|
||
if (parent) {
|
||
parent.replaceChild(elem, this)
|
||
}
|
||
} // Force callback invocation
|
||
}, ignored)
|
||
}
|
||
});
|
||
jQuery.each({
|
||
appendTo: 'append',
|
||
prependTo: 'prepend',
|
||
insertBefore: 'before',
|
||
insertAfter: 'after',
|
||
replaceAll: 'replaceWith'
|
||
}, function (name, original) {
|
||
jQuery.fn[name] = function (selector) {
|
||
var elems, ret = [], insert = jQuery(selector), last = insert.length - 1, i = 0;
|
||
for (; i <= last; i++) {
|
||
elems = i === last ? this : this.clone(true);
|
||
jQuery(insert[i])[original](elems);
|
||
// Support: QtWebKit
|
||
// .get() because push.apply(_, arraylike) throws
|
||
push.apply(ret, elems.get())
|
||
}
|
||
return this.pushStack(ret)
|
||
}
|
||
});
|
||
var iframe, elemdisplay = {
|
||
// Support: Firefox
|
||
// We have to pre-define these values for FF (#10227)
|
||
HTML: 'block',
|
||
BODY: 'block'
|
||
};
|
||
/**
|
||
* Retrieve the actual display of a element
|
||
* @param {String} name nodeName of the element
|
||
* @param {Object} doc Document object
|
||
*/
|
||
// Called only from within defaultDisplay
|
||
function actualDisplay(name, doc) {
|
||
var elem = jQuery(doc.createElement(name)).appendTo(doc.body), display = jQuery.css(elem[0], 'display');
|
||
// We don't have any data stored on the element,
|
||
// so use "detach" method as fast way to get rid of the element
|
||
elem.detach();
|
||
return display
|
||
}
|
||
/**
|
||
* Try to determine the default display value of an element
|
||
* @param {String} nodeName
|
||
*/
|
||
function defaultDisplay(nodeName) {
|
||
var doc = document, display = elemdisplay[nodeName];
|
||
if (!display) {
|
||
display = actualDisplay(nodeName, doc);
|
||
// If the simple way fails, read from inside an iframe
|
||
if (display === 'none' || !display) {
|
||
// Use the already-created iframe if possible
|
||
iframe = (iframe || jQuery("<iframe frameborder='0' width='0' height='0'/>")).appendTo(doc.documentElement);
|
||
// Always write a new HTML skeleton so Webkit and Firefox don't choke on reuse
|
||
doc = iframe[0].contentDocument;
|
||
// Support: IE
|
||
doc.write();
|
||
doc.close();
|
||
display = actualDisplay(nodeName, doc);
|
||
iframe.detach()
|
||
}
|
||
// Store the correct default display
|
||
elemdisplay[nodeName] = display
|
||
}
|
||
return display
|
||
}
|
||
var rmargin = /^margin/;
|
||
var rnumnonpx = new RegExp('^(' + pnum + ')(?!px)[a-z%]+$', 'i');
|
||
var getStyles = function (elem) {
|
||
// Support: IE<=11+, Firefox<=30+ (#15098, #14150)
|
||
// IE throws on elements created in popups
|
||
// FF meanwhile throws on frame elements through "defaultView.getComputedStyle"
|
||
var view = elem.ownerDocument.defaultView;
|
||
if (!view || !view.opener) {
|
||
view = window
|
||
}
|
||
return view.getComputedStyle(elem)
|
||
};
|
||
var swap = function (elem, options, callback, args) {
|
||
var ret, name, old = {};
|
||
// Remember the old values, and insert the new ones
|
||
for (name in options) {
|
||
old[name] = elem.style[name];
|
||
elem.style[name] = options[name]
|
||
}
|
||
ret = callback.apply(elem, args || []);
|
||
// Revert the old values
|
||
for (name in options) {
|
||
elem.style[name] = old[name]
|
||
}
|
||
return ret
|
||
};
|
||
var documentElement = document.documentElement;
|
||
(function () {
|
||
var pixelPositionVal, boxSizingReliableVal, pixelMarginRightVal, reliableMarginLeftVal, container = document.createElement('div'), div = document.createElement('div');
|
||
// Finish early in limited (non-browser) environments
|
||
if (!div.style) {
|
||
return
|
||
}
|
||
// Support: IE9-11+
|
||
// Style of cloned element affects source element cloned (#8908)
|
||
div.style.backgroundClip = 'content-box';
|
||
div.cloneNode(true).style.backgroundClip = '';
|
||
support.clearCloneStyle = div.style.backgroundClip === 'content-box';
|
||
container.style.cssText = 'border:0;width:8px;height:0;top:0;left:-9999px;' + 'padding:0;margin-top:1px;position:absolute';
|
||
container.appendChild(div);
|
||
// Executing both pixelPosition & boxSizingReliable tests require only one layout
|
||
// so they're executed at the same time to save the second computation.
|
||
function computeStyleTests() {
|
||
div.style.cssText = // Support: Firefox<29, Android 2.3
|
||
// Vendor-prefix box-sizing
|
||
'-webkit-box-sizing:border-box;-moz-box-sizing:border-box;box-sizing:border-box;' + 'position:relative;display:block;' + 'margin:auto;border:1px;padding:1px;' + 'top:1%;width:50%';
|
||
div.innerHTML = '';
|
||
documentElement.appendChild(container);
|
||
var divStyle = window.getComputedStyle(div);
|
||
pixelPositionVal = divStyle.top !== '1%';
|
||
reliableMarginLeftVal = divStyle.marginLeft === '2px';
|
||
boxSizingReliableVal = divStyle.width === '4px';
|
||
// Support: Android 4.0 - 4.3 only
|
||
// Some styles come back with percentage values, even though they shouldn't
|
||
div.style.marginRight = '50%';
|
||
pixelMarginRightVal = divStyle.marginRight === '4px';
|
||
documentElement.removeChild(container)
|
||
}
|
||
jQuery.extend(support, {
|
||
pixelPosition: function () {
|
||
// This test is executed only once but we still do memoizing
|
||
// since we can use the boxSizingReliable pre-computing.
|
||
// No need to check if the test was already performed, though.
|
||
computeStyleTests();
|
||
return pixelPositionVal
|
||
},
|
||
boxSizingReliable: function () {
|
||
if (boxSizingReliableVal == null) {
|
||
computeStyleTests()
|
||
}
|
||
return boxSizingReliableVal
|
||
},
|
||
pixelMarginRight: function () {
|
||
// Support: Android 4.0-4.3
|
||
// We're checking for boxSizingReliableVal here instead of pixelMarginRightVal
|
||
// since that compresses better and they're computed together anyway.
|
||
if (boxSizingReliableVal == null) {
|
||
computeStyleTests()
|
||
}
|
||
return pixelMarginRightVal
|
||
},
|
||
reliableMarginLeft: function () {
|
||
// Support: IE <=8 only, Android 4.0 - 4.3 only, Firefox <=3 - 37
|
||
if (boxSizingReliableVal == null) {
|
||
computeStyleTests()
|
||
}
|
||
return reliableMarginLeftVal
|
||
},
|
||
reliableMarginRight: function () {
|
||
// Support: Android 2.3
|
||
// Check if div with explicit width and no margin-right incorrectly
|
||
// gets computed margin-right based on width of container. (#3333)
|
||
// WebKit Bug 13343 - getComputedStyle returns wrong value for margin-right
|
||
// This support function is only executed once so no memoizing is needed.
|
||
var ret, marginDiv = div.appendChild(document.createElement('div'));
|
||
// Reset CSS: box-sizing; display; margin; border; padding
|
||
marginDiv.style.cssText = div.style.cssText = // Support: Android 2.3
|
||
// Vendor-prefix box-sizing
|
||
'-webkit-box-sizing:content-box;box-sizing:content-box;' + 'display:block;margin:0;border:0;padding:0';
|
||
marginDiv.style.marginRight = marginDiv.style.width = '0';
|
||
div.style.width = '1px';
|
||
documentElement.appendChild(container);
|
||
ret = !parseFloat(window.getComputedStyle(marginDiv).marginRight);
|
||
documentElement.removeChild(container);
|
||
div.removeChild(marginDiv);
|
||
return ret
|
||
}
|
||
})
|
||
}());
|
||
function curCSS(elem, name, computed) {
|
||
var width, minWidth, maxWidth, ret, style = elem.style;
|
||
computed = computed || getStyles(elem);
|
||
ret = computed ? computed.getPropertyValue(name) || computed[name] : undefined;
|
||
// Support: Opera 12.1x only
|
||
// Fall back to style even without computed
|
||
// computed is undefined for elems on document fragments
|
||
if ((ret === '' || ret === undefined) && !jQuery.contains(elem.ownerDocument, elem)) {
|
||
ret = jQuery.style(elem, name)
|
||
}
|
||
// Support: IE9
|
||
// getPropertyValue is only needed for .css('filter') (#12537)
|
||
if (computed) {
|
||
// A tribute to the "awesome hack by Dean Edwards"
|
||
// Android Browser returns percentage for some values,
|
||
// but width seems to be reliably pixels.
|
||
// This is against the CSSOM draft spec:
|
||
// http://dev.w3.org/csswg/cssom/#resolved-values
|
||
if (!support.pixelMarginRight() && rnumnonpx.test(ret) && rmargin.test(name)) {
|
||
// Remember the original values
|
||
width = style.width;
|
||
minWidth = style.minWidth;
|
||
maxWidth = style.maxWidth;
|
||
// Put in the new values to get a computed value out
|
||
style.minWidth = style.maxWidth = style.width = ret;
|
||
ret = computed.width;
|
||
// Revert the changed values
|
||
style.width = width;
|
||
style.minWidth = minWidth;
|
||
style.maxWidth = maxWidth
|
||
}
|
||
}
|
||
return ret !== undefined ? // Support: IE9-11+
|
||
// IE returns zIndex value as an integer.
|
||
ret + '' : ret
|
||
}
|
||
function addGetHookIf(conditionFn, hookFn) {
|
||
// Define the hook, we'll check on the first run if it's really needed.
|
||
return {
|
||
get: function () {
|
||
if (conditionFn()) {
|
||
// Hook not needed (or it's not possible to use it due
|
||
// to missing dependency), remove it.
|
||
delete this.get;
|
||
return
|
||
}
|
||
// Hook needed; redefine it so that the support test is not executed again.
|
||
return (this.get = hookFn).apply(this, arguments)
|
||
}
|
||
}
|
||
}
|
||
var
|
||
// Swappable if display is none or starts with table
|
||
// except "table", "table-cell", or "table-caption"
|
||
// See here for display values: https://developer.mozilla.org/en-US/docs/CSS/display
|
||
rdisplayswap = /^(none|table(?!-c[ea]).+)/, cssShow = {
|
||
position: 'absolute',
|
||
visibility: 'hidden',
|
||
display: 'block'
|
||
}, cssNormalTransform = {
|
||
letterSpacing: '0',
|
||
fontWeight: '400'
|
||
}, cssPrefixes = [
|
||
'Webkit',
|
||
'O',
|
||
'Moz',
|
||
'ms'
|
||
], emptyStyle = document.createElement('div').style;
|
||
// Return a css property mapped to a potentially vendor prefixed property
|
||
function vendorPropName(name) {
|
||
// Shortcut for names that are not vendor prefixed
|
||
if (name in emptyStyle) {
|
||
return name
|
||
}
|
||
// Check for vendor prefixed names
|
||
var capName = name[0].toUpperCase() + name.slice(1), i = cssPrefixes.length;
|
||
while (i--) {
|
||
name = cssPrefixes[i] + capName;
|
||
if (name in emptyStyle) {
|
||
return name
|
||
}
|
||
}
|
||
}
|
||
function setPositiveNumber(elem, value, subtract) {
|
||
// Any relative (+/-) values have already been
|
||
// normalized at this point
|
||
var matches = rcssNum.exec(value);
|
||
return matches ? // Guard against undefined "subtract", e.g., when used as in cssHooks
|
||
Math.max(0, matches[2] - (subtract || 0)) + (matches[3] || 'px') : value
|
||
}
|
||
function augmentWidthOrHeight(elem, name, extra, isBorderBox, styles) {
|
||
var i = extra === (isBorderBox ? 'border' : 'content') ? // If we already have the right measurement, avoid augmentation
|
||
4 : // Otherwise initialize for horizontal or vertical properties
|
||
name === 'width' ? 1 : 0, val = 0;
|
||
for (; i < 4; i += 2) {
|
||
// Both box models exclude margin, so add it if we want it
|
||
if (extra === 'margin') {
|
||
val += jQuery.css(elem, extra + cssExpand[i], true, styles)
|
||
}
|
||
if (isBorderBox) {
|
||
// border-box includes padding, so remove it if we want content
|
||
if (extra === 'content') {
|
||
val -= jQuery.css(elem, 'padding' + cssExpand[i], true, styles)
|
||
}
|
||
// At this point, extra isn't border nor margin, so remove border
|
||
if (extra !== 'margin') {
|
||
val -= jQuery.css(elem, 'border' + cssExpand[i] + 'Width', true, styles)
|
||
}
|
||
} else {
|
||
// At this point, extra isn't content, so add padding
|
||
val += jQuery.css(elem, 'padding' + cssExpand[i], true, styles);
|
||
// At this point, extra isn't content nor padding, so add border
|
||
if (extra !== 'padding') {
|
||
val += jQuery.css(elem, 'border' + cssExpand[i] + 'Width', true, styles)
|
||
}
|
||
}
|
||
}
|
||
return val
|
||
}
|
||
function getWidthOrHeight(elem, name, extra) {
|
||
// Start with offset property, which is equivalent to the border-box value
|
||
var valueIsBorderBox = true, val = name === 'width' ? elem.offsetWidth : elem.offsetHeight, styles = getStyles(elem), isBorderBox = jQuery.css(elem, 'boxSizing', false, styles) === 'border-box';
|
||
// Support: IE11 only
|
||
// In IE 11 fullscreen elements inside of an iframe have
|
||
// 100x too small dimensions (gh-1764).
|
||
if (document.msFullscreenElement && window.top !== window) {
|
||
// Support: IE11 only
|
||
// Running getBoundingClientRect on a disconnected node
|
||
// in IE throws an error.
|
||
if (elem.getClientRects().length) {
|
||
val = Math.round(elem.getBoundingClientRect()[name] * 100)
|
||
}
|
||
}
|
||
// Some non-html elements return undefined for offsetWidth, so check for null/undefined
|
||
// svg - https://bugzilla.mozilla.org/show_bug.cgi?id=649285
|
||
// MathML - https://bugzilla.mozilla.org/show_bug.cgi?id=491668
|
||
if (val <= 0 || val == null) {
|
||
// Fall back to computed then uncomputed css if necessary
|
||
val = curCSS(elem, name, styles);
|
||
if (val < 0 || val == null) {
|
||
val = elem.style[name]
|
||
}
|
||
// Computed unit is not pixels. Stop here and return.
|
||
if (rnumnonpx.test(val)) {
|
||
return val
|
||
}
|
||
// Check for style in case a browser which returns unreliable values
|
||
// for getComputedStyle silently falls back to the reliable elem.style
|
||
valueIsBorderBox = isBorderBox && (support.boxSizingReliable() || val === elem.style[name]);
|
||
// Normalize "", auto, and prepare for extra
|
||
val = parseFloat(val) || 0
|
||
}
|
||
// Use the active box-sizing model to add/subtract irrelevant styles
|
||
return val + augmentWidthOrHeight(elem, name, extra || (isBorderBox ? 'border' : 'content'), valueIsBorderBox, styles) + 'px'
|
||
}
|
||
function showHide(elements, show) {
|
||
var display, elem, hidden, values = [], index = 0, length = elements.length;
|
||
for (; index < length; index++) {
|
||
elem = elements[index];
|
||
if (!elem.style) {
|
||
continue
|
||
}
|
||
values[index] = dataPriv.get(elem, 'olddisplay');
|
||
display = elem.style.display;
|
||
if (show) {
|
||
// Reset the inline display of this element to learn if it is
|
||
// being hidden by cascaded rules or not
|
||
if (!values[index] && display === 'none') {
|
||
elem.style.display = ''
|
||
}
|
||
// Set elements which have been overridden with display: none
|
||
// in a stylesheet to whatever the default browser style is
|
||
// for such an element
|
||
if (elem.style.display === '' && isHidden(elem)) {
|
||
values[index] = dataPriv.access(elem, 'olddisplay', defaultDisplay(elem.nodeName))
|
||
}
|
||
} else {
|
||
hidden = isHidden(elem);
|
||
if (display !== 'none' || !hidden) {
|
||
dataPriv.set(elem, 'olddisplay', hidden ? display : jQuery.css(elem, 'display'))
|
||
}
|
||
}
|
||
}
|
||
// Set the display of most of the elements in a second loop
|
||
// to avoid the constant reflow
|
||
for (index = 0; index < length; index++) {
|
||
elem = elements[index];
|
||
if (!elem.style) {
|
||
continue
|
||
}
|
||
if (!show || elem.style.display === 'none' || elem.style.display === '') {
|
||
elem.style.display = show ? values[index] || '' : 'none'
|
||
}
|
||
}
|
||
return elements
|
||
}
|
||
jQuery.extend({
|
||
// Add in style property hooks for overriding the default
|
||
// behavior of getting and setting a style property
|
||
cssHooks: {
|
||
opacity: {
|
||
get: function (elem, computed) {
|
||
if (computed) {
|
||
// We should always get a number back from opacity
|
||
var ret = curCSS(elem, 'opacity');
|
||
return ret === '' ? '1' : ret
|
||
}
|
||
}
|
||
}
|
||
},
|
||
// Don't automatically add "px" to these possibly-unitless properties
|
||
cssNumber: {
|
||
'animationIterationCount': true,
|
||
'columnCount': true,
|
||
'fillOpacity': true,
|
||
'flexGrow': true,
|
||
'flexShrink': true,
|
||
'fontWeight': true,
|
||
'lineHeight': true,
|
||
'opacity': true,
|
||
'order': true,
|
||
'orphans': true,
|
||
'widows': true,
|
||
'zIndex': true,
|
||
'zoom': true
|
||
},
|
||
// Add in properties whose names you wish to fix before
|
||
// setting or getting the value
|
||
cssProps: { 'float': 'cssFloat' },
|
||
// Get and set the style property on a DOM Node
|
||
style: function (elem, name, value, extra) {
|
||
// Don't set styles on text and comment nodes
|
||
if (!elem || elem.nodeType === 3 || elem.nodeType === 8 || !elem.style) {
|
||
return
|
||
}
|
||
// Make sure that we're working with the right name
|
||
var ret, type, hooks, origName = jQuery.camelCase(name), style = elem.style;
|
||
name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(origName) || origName);
|
||
// Gets hook for the prefixed version, then unprefixed version
|
||
hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
|
||
// Check if we're setting a value
|
||
if (value !== undefined) {
|
||
type = typeof value;
|
||
// Convert "+=" or "-=" to relative numbers (#7345)
|
||
if (type === 'string' && (ret = rcssNum.exec(value)) && ret[1]) {
|
||
value = adjustCSS(elem, name, ret);
|
||
// Fixes bug #9237
|
||
type = 'number'
|
||
}
|
||
// Make sure that null and NaN values aren't set (#7116)
|
||
if (value == null || value !== value) {
|
||
return
|
||
}
|
||
// If a number was passed in, add the unit (except for certain CSS properties)
|
||
if (type === 'number') {
|
||
value += ret && ret[3] || (jQuery.cssNumber[origName] ? '' : 'px')
|
||
}
|
||
// Support: IE9-11+
|
||
// background-* props affect original clone's values
|
||
if (!support.clearCloneStyle && value === '' && name.indexOf('background') === 0) {
|
||
style[name] = 'inherit'
|
||
}
|
||
// If a hook was provided, use that value, otherwise just set the specified value
|
||
if (!hooks || !('set' in hooks) || (value = hooks.set(elem, value, extra)) !== undefined) {
|
||
style[name] = value
|
||
}
|
||
} else {
|
||
// If a hook was provided get the non-computed value from there
|
||
if (hooks && 'get' in hooks && (ret = hooks.get(elem, false, extra)) !== undefined) {
|
||
return ret
|
||
}
|
||
// Otherwise just get the value from the style object
|
||
return style[name]
|
||
}
|
||
},
|
||
css: function (elem, name, extra, styles) {
|
||
var val, num, hooks, origName = jQuery.camelCase(name);
|
||
// Make sure that we're working with the right name
|
||
name = jQuery.cssProps[origName] || (jQuery.cssProps[origName] = vendorPropName(origName) || origName);
|
||
// Try prefixed name followed by the unprefixed name
|
||
hooks = jQuery.cssHooks[name] || jQuery.cssHooks[origName];
|
||
// If a hook was provided get the computed value from there
|
||
if (hooks && 'get' in hooks) {
|
||
val = hooks.get(elem, true, extra)
|
||
}
|
||
// Otherwise, if a way to get the computed value exists, use that
|
||
if (val === undefined) {
|
||
val = curCSS(elem, name, styles)
|
||
}
|
||
// Convert "normal" to computed value
|
||
if (val === 'normal' && name in cssNormalTransform) {
|
||
val = cssNormalTransform[name]
|
||
}
|
||
// Make numeric if forced or a qualifier was provided and val looks numeric
|
||
if (extra === '' || extra) {
|
||
num = parseFloat(val);
|
||
return extra === true || isFinite(num) ? num || 0 : val
|
||
}
|
||
return val
|
||
}
|
||
});
|
||
jQuery.each([
|
||
'height',
|
||
'width'
|
||
], function (i, name) {
|
||
jQuery.cssHooks[name] = {
|
||
get: function (elem, computed, extra) {
|
||
if (computed) {
|
||
// Certain elements can have dimension info if we invisibly show them
|
||
// but it must have a current display style that would benefit
|
||
return rdisplayswap.test(jQuery.css(elem, 'display')) && elem.offsetWidth === 0 ? swap(elem, cssShow, function () {
|
||
return getWidthOrHeight(elem, name, extra)
|
||
}) : getWidthOrHeight(elem, name, extra)
|
||
}
|
||
},
|
||
set: function (elem, value, extra) {
|
||
var matches, styles = extra && getStyles(elem), subtract = extra && augmentWidthOrHeight(elem, name, extra, jQuery.css(elem, 'boxSizing', false, styles) === 'border-box', styles);
|
||
// Convert to pixels if value adjustment is needed
|
||
if (subtract && (matches = rcssNum.exec(value)) && (matches[3] || 'px') !== 'px') {
|
||
elem.style[name] = value;
|
||
value = jQuery.css(elem, name)
|
||
}
|
||
return setPositiveNumber(elem, value, subtract)
|
||
}
|
||
}
|
||
});
|
||
jQuery.cssHooks.marginLeft = addGetHookIf(support.reliableMarginLeft, function (elem, computed) {
|
||
if (computed) {
|
||
return (parseFloat(curCSS(elem, 'marginLeft')) || elem.getBoundingClientRect().left - swap(elem, { marginLeft: 0 }, function () {
|
||
return elem.getBoundingClientRect().left
|
||
})) + 'px'
|
||
}
|
||
});
|
||
// Support: Android 2.3
|
||
jQuery.cssHooks.marginRight = addGetHookIf(support.reliableMarginRight, function (elem, computed) {
|
||
if (computed) {
|
||
return swap(elem, { 'display': 'inline-block' }, curCSS, [
|
||
elem,
|
||
'marginRight'
|
||
])
|
||
}
|
||
});
|
||
// These hooks are used by animate to expand properties
|
||
jQuery.each({
|
||
margin: '',
|
||
padding: '',
|
||
border: 'Width'
|
||
}, function (prefix, suffix) {
|
||
jQuery.cssHooks[prefix + suffix] = {
|
||
expand: function (value) {
|
||
var i = 0, expanded = {},
|
||
// Assumes a single number if not a string
|
||
parts = typeof value === 'string' ? value.split(' ') : [value];
|
||
for (; i < 4; i++) {
|
||
expanded[prefix + cssExpand[i] + suffix] = parts[i] || parts[i - 2] || parts[0]
|
||
}
|
||
return expanded
|
||
}
|
||
};
|
||
if (!rmargin.test(prefix)) {
|
||
jQuery.cssHooks[prefix + suffix].set = setPositiveNumber
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
css: function (name, value) {
|
||
return access(this, function (elem, name, value) {
|
||
var styles, len, map = {}, i = 0;
|
||
if (jQuery.isArray(name)) {
|
||
styles = getStyles(elem);
|
||
len = name.length;
|
||
for (; i < len; i++) {
|
||
map[name[i]] = jQuery.css(elem, name[i], false, styles)
|
||
}
|
||
return map
|
||
}
|
||
return value !== undefined ? jQuery.style(elem, name, value) : jQuery.css(elem, name)
|
||
}, name, value, arguments.length > 1)
|
||
},
|
||
show: function () {
|
||
return showHide(this, true)
|
||
},
|
||
hide: function () {
|
||
return showHide(this)
|
||
},
|
||
toggle: function (state) {
|
||
if (typeof state === 'boolean') {
|
||
return state ? this.show() : this.hide()
|
||
}
|
||
return this.each(function () {
|
||
if (isHidden(this)) {
|
||
jQuery(this).show()
|
||
} else {
|
||
jQuery(this).hide()
|
||
}
|
||
})
|
||
}
|
||
});
|
||
function Tween(elem, options, prop, end, easing) {
|
||
return new Tween.prototype.init(elem, options, prop, end, easing)
|
||
}
|
||
jQuery.Tween = Tween;
|
||
Tween.prototype = {
|
||
constructor: Tween,
|
||
init: function (elem, options, prop, end, easing, unit) {
|
||
this.elem = elem;
|
||
this.prop = prop;
|
||
this.easing = easing || jQuery.easing._default;
|
||
this.options = options;
|
||
this.start = this.now = this.cur();
|
||
this.end = end;
|
||
this.unit = unit || (jQuery.cssNumber[prop] ? '' : 'px')
|
||
},
|
||
cur: function () {
|
||
var hooks = Tween.propHooks[this.prop];
|
||
return hooks && hooks.get ? hooks.get(this) : Tween.propHooks._default.get(this)
|
||
},
|
||
run: function (percent) {
|
||
var eased, hooks = Tween.propHooks[this.prop];
|
||
if (this.options.duration) {
|
||
this.pos = eased = jQuery.easing[this.easing](percent, this.options.duration * percent, 0, 1, this.options.duration)
|
||
} else {
|
||
this.pos = eased = percent
|
||
}
|
||
this.now = (this.end - this.start) * eased + this.start;
|
||
if (this.options.step) {
|
||
this.options.step.call(this.elem, this.now, this)
|
||
}
|
||
if (hooks && hooks.set) {
|
||
hooks.set(this)
|
||
} else {
|
||
Tween.propHooks._default.set(this)
|
||
}
|
||
return this
|
||
}
|
||
};
|
||
Tween.prototype.init.prototype = Tween.prototype;
|
||
Tween.propHooks = {
|
||
_default: {
|
||
get: function (tween) {
|
||
var result;
|
||
// Use a property on the element directly when it is not a DOM element,
|
||
// or when there is no matching style property that exists.
|
||
if (tween.elem.nodeType !== 1 || tween.elem[tween.prop] != null && tween.elem.style[tween.prop] == null) {
|
||
return tween.elem[tween.prop]
|
||
}
|
||
// Passing an empty string as a 3rd parameter to .css will automatically
|
||
// attempt a parseFloat and fallback to a string if the parse fails.
|
||
// Simple values such as "10px" are parsed to Float;
|
||
// complex values such as "rotate(1rad)" are returned as-is.
|
||
result = jQuery.css(tween.elem, tween.prop, '');
|
||
// Empty strings, null, undefined and "auto" are converted to 0.
|
||
return !result || result === 'auto' ? 0 : result
|
||
},
|
||
set: function (tween) {
|
||
// Use step hook for back compat.
|
||
// Use cssHook if its there.
|
||
// Use .style if available and use plain properties where available.
|
||
if (jQuery.fx.step[tween.prop]) {
|
||
jQuery.fx.step[tween.prop](tween)
|
||
} else if (tween.elem.nodeType === 1 && (tween.elem.style[jQuery.cssProps[tween.prop]] != null || jQuery.cssHooks[tween.prop])) {
|
||
jQuery.style(tween.elem, tween.prop, tween.now + tween.unit)
|
||
} else {
|
||
tween.elem[tween.prop] = tween.now
|
||
}
|
||
}
|
||
}
|
||
};
|
||
// Support: IE9
|
||
// Panic based approach to setting things on disconnected nodes
|
||
Tween.propHooks.scrollTop = Tween.propHooks.scrollLeft = {
|
||
set: function (tween) {
|
||
if (tween.elem.nodeType && tween.elem.parentNode) {
|
||
tween.elem[tween.prop] = tween.now
|
||
}
|
||
}
|
||
};
|
||
jQuery.easing = {
|
||
linear: function (p) {
|
||
return p
|
||
},
|
||
swing: function (p) {
|
||
return 0.5 - Math.cos(p * Math.PI) / 2
|
||
},
|
||
_default: 'swing'
|
||
};
|
||
jQuery.fx = Tween.prototype.init;
|
||
// Back Compat <1.8 extension point
|
||
jQuery.fx.step = {};
|
||
var fxNow, timerId, rfxtypes = /^(?:toggle|show|hide)$/, rrun = /queueHooks$/;
|
||
// Animations created synchronously will run synchronously
|
||
function createFxNow() {
|
||
window.setTimeout(function () {
|
||
fxNow = undefined
|
||
});
|
||
return fxNow = jQuery.now()
|
||
}
|
||
// Generate parameters to create a standard animation
|
||
function genFx(type, includeWidth) {
|
||
var which, i = 0, attrs = { height: type };
|
||
// If we include width, step value is 1 to do all cssExpand values,
|
||
// otherwise step value is 2 to skip over Left and Right
|
||
includeWidth = includeWidth ? 1 : 0;
|
||
for (; i < 4; i += 2 - includeWidth) {
|
||
which = cssExpand[i];
|
||
attrs['margin' + which] = attrs['padding' + which] = type
|
||
}
|
||
if (includeWidth) {
|
||
attrs.opacity = attrs.width = type
|
||
}
|
||
return attrs
|
||
}
|
||
function createTween(value, prop, animation) {
|
||
var tween, collection = (Animation.tweeners[prop] || []).concat(Animation.tweeners['*']), index = 0, length = collection.length;
|
||
for (; index < length; index++) {
|
||
if (tween = collection[index].call(animation, prop, value)) {
|
||
// We're done with this property
|
||
return tween
|
||
}
|
||
}
|
||
}
|
||
function defaultPrefilter(elem, props, opts) {
|
||
/* jshint validthis: true */
|
||
var prop, value, toggle, tween, hooks, oldfire, display, checkDisplay, anim = this, orig = {}, style = elem.style, hidden = elem.nodeType && isHidden(elem), dataShow = dataPriv.get(elem, 'fxshow');
|
||
// Handle queue: false promises
|
||
if (!opts.queue) {
|
||
hooks = jQuery._queueHooks(elem, 'fx');
|
||
if (hooks.unqueued == null) {
|
||
hooks.unqueued = 0;
|
||
oldfire = hooks.empty.fire;
|
||
hooks.empty.fire = function () {
|
||
if (!hooks.unqueued) {
|
||
oldfire()
|
||
}
|
||
}
|
||
}
|
||
hooks.unqueued++;
|
||
anim.always(function () {
|
||
// Ensure the complete handler is called before this completes
|
||
anim.always(function () {
|
||
hooks.unqueued--;
|
||
if (!jQuery.queue(elem, 'fx').length) {
|
||
hooks.empty.fire()
|
||
}
|
||
})
|
||
})
|
||
}
|
||
// Height/width overflow pass
|
||
if (elem.nodeType === 1 && ('height' in props || 'width' in props)) {
|
||
// Make sure that nothing sneaks out
|
||
// Record all 3 overflow attributes because IE9-10 do not
|
||
// change the overflow attribute when overflowX and
|
||
// overflowY are set to the same value
|
||
opts.overflow = [
|
||
style.overflow,
|
||
style.overflowX,
|
||
style.overflowY
|
||
];
|
||
// Set display property to inline-block for height/width
|
||
// animations on inline elements that are having width/height animated
|
||
display = jQuery.css(elem, 'display');
|
||
// Test default display if display is currently "none"
|
||
checkDisplay = display === 'none' ? dataPriv.get(elem, 'olddisplay') || defaultDisplay(elem.nodeName) : display;
|
||
if (checkDisplay === 'inline' && jQuery.css(elem, 'float') === 'none') {
|
||
style.display = 'inline-block'
|
||
}
|
||
}
|
||
if (opts.overflow) {
|
||
style.overflow = 'hidden';
|
||
anim.always(function () {
|
||
style.overflow = opts.overflow[0];
|
||
style.overflowX = opts.overflow[1];
|
||
style.overflowY = opts.overflow[2]
|
||
})
|
||
}
|
||
// show/hide pass
|
||
for (prop in props) {
|
||
value = props[prop];
|
||
if (rfxtypes.exec(value)) {
|
||
delete props[prop];
|
||
toggle = toggle || value === 'toggle';
|
||
if (value === (hidden ? 'hide' : 'show')) {
|
||
// If there is dataShow left over from a stopped hide or show
|
||
// and we are going to proceed with show, we should pretend to be hidden
|
||
if (value === 'show' && dataShow && dataShow[prop] !== undefined) {
|
||
hidden = true
|
||
} else {
|
||
continue
|
||
}
|
||
}
|
||
orig[prop] = dataShow && dataShow[prop] || jQuery.style(elem, prop) // Any non-fx value stops us from restoring the original display value
|
||
} else {
|
||
display = undefined
|
||
}
|
||
}
|
||
if (!jQuery.isEmptyObject(orig)) {
|
||
if (dataShow) {
|
||
if ('hidden' in dataShow) {
|
||
hidden = dataShow.hidden
|
||
}
|
||
} else {
|
||
dataShow = dataPriv.access(elem, 'fxshow', {})
|
||
}
|
||
// Store state if its toggle - enables .stop().toggle() to "reverse"
|
||
if (toggle) {
|
||
dataShow.hidden = !hidden
|
||
}
|
||
if (hidden) {
|
||
jQuery(elem).show()
|
||
} else {
|
||
anim.done(function () {
|
||
jQuery(elem).hide()
|
||
})
|
||
}
|
||
anim.done(function () {
|
||
var prop;
|
||
dataPriv.remove(elem, 'fxshow');
|
||
for (prop in orig) {
|
||
jQuery.style(elem, prop, orig[prop])
|
||
}
|
||
});
|
||
for (prop in orig) {
|
||
tween = createTween(hidden ? dataShow[prop] : 0, prop, anim);
|
||
if (!(prop in dataShow)) {
|
||
dataShow[prop] = tween.start;
|
||
if (hidden) {
|
||
tween.end = tween.start;
|
||
tween.start = prop === 'width' || prop === 'height' ? 1 : 0
|
||
}
|
||
}
|
||
} // If this is a noop like .hide().hide(), restore an overwritten display value
|
||
} else if ((display === 'none' ? defaultDisplay(elem.nodeName) : display) === 'inline') {
|
||
style.display = display
|
||
}
|
||
}
|
||
function propFilter(props, specialEasing) {
|
||
var index, name, easing, value, hooks;
|
||
// camelCase, specialEasing and expand cssHook pass
|
||
for (index in props) {
|
||
name = jQuery.camelCase(index);
|
||
easing = specialEasing[name];
|
||
value = props[index];
|
||
if (jQuery.isArray(value)) {
|
||
easing = value[1];
|
||
value = props[index] = value[0]
|
||
}
|
||
if (index !== name) {
|
||
props[name] = value;
|
||
delete props[index]
|
||
}
|
||
hooks = jQuery.cssHooks[name];
|
||
if (hooks && 'expand' in hooks) {
|
||
value = hooks.expand(value);
|
||
delete props[name];
|
||
// Not quite $.extend, this won't overwrite existing keys.
|
||
// Reusing 'index' because we have the correct "name"
|
||
for (index in value) {
|
||
if (!(index in props)) {
|
||
props[index] = value[index];
|
||
specialEasing[index] = easing
|
||
}
|
||
}
|
||
} else {
|
||
specialEasing[name] = easing
|
||
}
|
||
}
|
||
}
|
||
function Animation(elem, properties, options) {
|
||
var result, stopped, index = 0, length = Animation.prefilters.length, deferred = jQuery.Deferred().always(function () {
|
||
// Don't match elem in the :animated selector
|
||
delete tick.elem
|
||
}), tick = function () {
|
||
if (stopped) {
|
||
return false
|
||
}
|
||
var currentTime = fxNow || createFxNow(), remaining = Math.max(0, animation.startTime + animation.duration - currentTime),
|
||
// Support: Android 2.3
|
||
// Archaic crash bug won't allow us to use `1 - ( 0.5 || 0 )` (#12497)
|
||
temp = remaining / animation.duration || 0, percent = 1 - temp, index = 0, length = animation.tweens.length;
|
||
for (; index < length; index++) {
|
||
animation.tweens[index].run(percent)
|
||
}
|
||
deferred.notifyWith(elem, [
|
||
animation,
|
||
percent,
|
||
remaining
|
||
]);
|
||
if (percent < 1 && length) {
|
||
return remaining
|
||
} else {
|
||
deferred.resolveWith(elem, [animation]);
|
||
return false
|
||
}
|
||
}, animation = deferred.promise({
|
||
elem: elem,
|
||
props: jQuery.extend({}, properties),
|
||
opts: jQuery.extend(true, {
|
||
specialEasing: {},
|
||
easing: jQuery.easing._default
|
||
}, options),
|
||
originalProperties: properties,
|
||
originalOptions: options,
|
||
startTime: fxNow || createFxNow(),
|
||
duration: options.duration,
|
||
tweens: [],
|
||
createTween: function (prop, end) {
|
||
var tween = jQuery.Tween(elem, animation.opts, prop, end, animation.opts.specialEasing[prop] || animation.opts.easing);
|
||
animation.tweens.push(tween);
|
||
return tween
|
||
},
|
||
stop: function (gotoEnd) {
|
||
var index = 0,
|
||
// If we are going to the end, we want to run all the tweens
|
||
// otherwise we skip this part
|
||
length = gotoEnd ? animation.tweens.length : 0;
|
||
if (stopped) {
|
||
return this
|
||
}
|
||
stopped = true;
|
||
for (; index < length; index++) {
|
||
animation.tweens[index].run(1)
|
||
}
|
||
// Resolve when we played the last frame; otherwise, reject
|
||
if (gotoEnd) {
|
||
deferred.notifyWith(elem, [
|
||
animation,
|
||
1,
|
||
0
|
||
]);
|
||
deferred.resolveWith(elem, [
|
||
animation,
|
||
gotoEnd
|
||
])
|
||
} else {
|
||
deferred.rejectWith(elem, [
|
||
animation,
|
||
gotoEnd
|
||
])
|
||
}
|
||
return this
|
||
}
|
||
}), props = animation.props;
|
||
propFilter(props, animation.opts.specialEasing);
|
||
for (; index < length; index++) {
|
||
result = Animation.prefilters[index].call(animation, elem, props, animation.opts);
|
||
if (result) {
|
||
if (jQuery.isFunction(result.stop)) {
|
||
jQuery._queueHooks(animation.elem, animation.opts.queue).stop = jQuery.proxy(result.stop, result)
|
||
}
|
||
return result
|
||
}
|
||
}
|
||
jQuery.map(props, createTween, animation);
|
||
if (jQuery.isFunction(animation.opts.start)) {
|
||
animation.opts.start.call(elem, animation)
|
||
}
|
||
jQuery.fx.timer(jQuery.extend(tick, {
|
||
elem: elem,
|
||
anim: animation,
|
||
queue: animation.opts.queue
|
||
}));
|
||
// attach callbacks from options
|
||
return animation.progress(animation.opts.progress).done(animation.opts.done, animation.opts.complete).fail(animation.opts.fail).always(animation.opts.always)
|
||
}
|
||
jQuery.Animation = jQuery.extend(Animation, {
|
||
tweeners: {
|
||
'*': [function (prop, value) {
|
||
var tween = this.createTween(prop, value);
|
||
adjustCSS(tween.elem, prop, rcssNum.exec(value), tween);
|
||
return tween
|
||
}]
|
||
},
|
||
tweener: function (props, callback) {
|
||
if (jQuery.isFunction(props)) {
|
||
callback = props;
|
||
props = ['*']
|
||
} else {
|
||
props = props.match(rnotwhite)
|
||
}
|
||
var prop, index = 0, length = props.length;
|
||
for (; index < length; index++) {
|
||
prop = props[index];
|
||
Animation.tweeners[prop] = Animation.tweeners[prop] || [];
|
||
Animation.tweeners[prop].unshift(callback)
|
||
}
|
||
},
|
||
prefilters: [defaultPrefilter],
|
||
prefilter: function (callback, prepend) {
|
||
if (prepend) {
|
||
Animation.prefilters.unshift(callback)
|
||
} else {
|
||
Animation.prefilters.push(callback)
|
||
}
|
||
}
|
||
});
|
||
jQuery.speed = function (speed, easing, fn) {
|
||
var opt = speed && typeof speed === 'object' ? jQuery.extend({}, speed) : {
|
||
complete: fn || !fn && easing || jQuery.isFunction(speed) && speed,
|
||
duration: speed,
|
||
easing: fn && easing || easing && !jQuery.isFunction(easing) && easing
|
||
};
|
||
opt.duration = jQuery.fx.off ? 0 : typeof opt.duration === 'number' ? opt.duration : opt.duration in jQuery.fx.speeds ? jQuery.fx.speeds[opt.duration] : jQuery.fx.speeds._default;
|
||
// Normalize opt.queue - true/undefined/null -> "fx"
|
||
if (opt.queue == null || opt.queue === true) {
|
||
opt.queue = 'fx'
|
||
}
|
||
// Queueing
|
||
opt.old = opt.complete;
|
||
opt.complete = function () {
|
||
if (jQuery.isFunction(opt.old)) {
|
||
opt.old.call(this)
|
||
}
|
||
if (opt.queue) {
|
||
jQuery.dequeue(this, opt.queue)
|
||
}
|
||
};
|
||
return opt
|
||
};
|
||
jQuery.fn.extend({
|
||
fadeTo: function (speed, to, easing, callback) {
|
||
// Show any hidden elements after setting opacity to 0
|
||
return this.filter(isHidden).css('opacity', 0).show() // Animate to the value specified
|
||
.end().animate({ opacity: to }, speed, easing, callback)
|
||
},
|
||
animate: function (prop, speed, easing, callback) {
|
||
var empty = jQuery.isEmptyObject(prop), optall = jQuery.speed(speed, easing, callback), doAnimation = function () {
|
||
// Operate on a copy of prop so per-property easing won't be lost
|
||
var anim = Animation(this, jQuery.extend({}, prop), optall);
|
||
// Empty animations, or finishing resolves immediately
|
||
if (empty || dataPriv.get(this, 'finish')) {
|
||
anim.stop(true)
|
||
}
|
||
};
|
||
doAnimation.finish = doAnimation;
|
||
return empty || optall.queue === false ? this.each(doAnimation) : this.queue(optall.queue, doAnimation)
|
||
},
|
||
stop: function (type, clearQueue, gotoEnd) {
|
||
var stopQueue = function (hooks) {
|
||
var stop = hooks.stop;
|
||
delete hooks.stop;
|
||
stop(gotoEnd)
|
||
};
|
||
if (typeof type !== 'string') {
|
||
gotoEnd = clearQueue;
|
||
clearQueue = type;
|
||
type = undefined
|
||
}
|
||
if (clearQueue && type !== false) {
|
||
this.queue(type || 'fx', [])
|
||
}
|
||
return this.each(function () {
|
||
var dequeue = true, index = type != null && type + 'queueHooks', timers = jQuery.timers, data = dataPriv.get(this);
|
||
if (index) {
|
||
if (data[index] && data[index].stop) {
|
||
stopQueue(data[index])
|
||
}
|
||
} else {
|
||
for (index in data) {
|
||
if (data[index] && data[index].stop && rrun.test(index)) {
|
||
stopQueue(data[index])
|
||
}
|
||
}
|
||
}
|
||
for (index = timers.length; index--;) {
|
||
if (timers[index].elem === this && (type == null || timers[index].queue === type)) {
|
||
timers[index].anim.stop(gotoEnd);
|
||
dequeue = false;
|
||
timers.splice(index, 1)
|
||
}
|
||
}
|
||
// Start the next in the queue if the last step wasn't forced.
|
||
// Timers currently will call their complete callbacks, which
|
||
// will dequeue but only if they were gotoEnd.
|
||
if (dequeue || !gotoEnd) {
|
||
jQuery.dequeue(this, type)
|
||
}
|
||
})
|
||
},
|
||
finish: function (type) {
|
||
if (type !== false) {
|
||
type = type || 'fx'
|
||
}
|
||
return this.each(function () {
|
||
var index, data = dataPriv.get(this), queue = data[type + 'queue'], hooks = data[type + 'queueHooks'], timers = jQuery.timers, length = queue ? queue.length : 0;
|
||
// Enable finishing flag on private data
|
||
data.finish = true;
|
||
// Empty the queue first
|
||
jQuery.queue(this, type, []);
|
||
if (hooks && hooks.stop) {
|
||
hooks.stop.call(this, true)
|
||
}
|
||
// Look for any active animations, and finish them
|
||
for (index = timers.length; index--;) {
|
||
if (timers[index].elem === this && timers[index].queue === type) {
|
||
timers[index].anim.stop(true);
|
||
timers.splice(index, 1)
|
||
}
|
||
}
|
||
// Look for any animations in the old queue and finish them
|
||
for (index = 0; index < length; index++) {
|
||
if (queue[index] && queue[index].finish) {
|
||
queue[index].finish.call(this)
|
||
}
|
||
}
|
||
// Turn off finishing flag
|
||
delete data.finish
|
||
})
|
||
}
|
||
});
|
||
jQuery.each([
|
||
'toggle',
|
||
'show',
|
||
'hide'
|
||
], function (i, name) {
|
||
var cssFn = jQuery.fn[name];
|
||
jQuery.fn[name] = function (speed, easing, callback) {
|
||
return speed == null || typeof speed === 'boolean' ? cssFn.apply(this, arguments) : this.animate(genFx(name, true), speed, easing, callback)
|
||
}
|
||
});
|
||
// Generate shortcuts for custom animations
|
||
jQuery.each({
|
||
slideDown: genFx('show'),
|
||
slideUp: genFx('hide'),
|
||
slideToggle: genFx('toggle'),
|
||
fadeIn: { opacity: 'show' },
|
||
fadeOut: { opacity: 'hide' },
|
||
fadeToggle: { opacity: 'toggle' }
|
||
}, function (name, props) {
|
||
jQuery.fn[name] = function (speed, easing, callback) {
|
||
return this.animate(props, speed, easing, callback)
|
||
}
|
||
});
|
||
jQuery.timers = [];
|
||
jQuery.fx.tick = function () {
|
||
var timer, i = 0, timers = jQuery.timers;
|
||
fxNow = jQuery.now();
|
||
for (; i < timers.length; i++) {
|
||
timer = timers[i];
|
||
// Checks the timer has not already been removed
|
||
if (!timer() && timers[i] === timer) {
|
||
timers.splice(i--, 1)
|
||
}
|
||
}
|
||
if (!timers.length) {
|
||
jQuery.fx.stop()
|
||
}
|
||
fxNow = undefined
|
||
};
|
||
jQuery.fx.timer = function (timer) {
|
||
jQuery.timers.push(timer);
|
||
if (timer()) {
|
||
jQuery.fx.start()
|
||
} else {
|
||
jQuery.timers.pop()
|
||
}
|
||
};
|
||
jQuery.fx.interval = 13;
|
||
jQuery.fx.start = function () {
|
||
if (!timerId) {
|
||
timerId = window.setInterval(jQuery.fx.tick, jQuery.fx.interval)
|
||
}
|
||
};
|
||
jQuery.fx.stop = function () {
|
||
window.clearInterval(timerId);
|
||
timerId = null
|
||
};
|
||
jQuery.fx.speeds = {
|
||
slow: 600,
|
||
fast: 200,
|
||
// Default speed
|
||
_default: 400
|
||
};
|
||
// Based off of the plugin by Clint Helfers, with permission.
|
||
// http://web.archive.org/web/20100324014747/http://blindsignals.com/index.php/2009/07/jquery-delay/
|
||
jQuery.fn.delay = function (time, type) {
|
||
time = jQuery.fx ? jQuery.fx.speeds[time] || time : time;
|
||
type = type || 'fx';
|
||
return this.queue(type, function (next, hooks) {
|
||
var timeout = window.setTimeout(next, time);
|
||
hooks.stop = function () {
|
||
window.clearTimeout(timeout)
|
||
}
|
||
})
|
||
};
|
||
(function () {
|
||
var input = document.createElement('input'), select = document.createElement('select'), opt = select.appendChild(document.createElement('option'));
|
||
input.type = 'checkbox';
|
||
// Support: iOS<=5.1, Android<=4.2+
|
||
// Default value for a checkbox should be "on"
|
||
support.checkOn = input.value !== '';
|
||
// Support: IE<=11+
|
||
// Must access selectedIndex to make default options select
|
||
support.optSelected = opt.selected;
|
||
// Support: Android<=2.3
|
||
// Options inside disabled selects are incorrectly marked as disabled
|
||
select.disabled = true;
|
||
support.optDisabled = !opt.disabled;
|
||
// Support: IE<=11+
|
||
// An input loses its value after becoming a radio
|
||
input = document.createElement('input');
|
||
input.value = 't';
|
||
input.type = 'radio';
|
||
support.radioValue = input.value === 't'
|
||
}());
|
||
var boolHook, attrHandle = jQuery.expr.attrHandle;
|
||
jQuery.fn.extend({
|
||
attr: function (name, value) {
|
||
return access(this, jQuery.attr, name, value, arguments.length > 1)
|
||
},
|
||
removeAttr: function (name) {
|
||
return this.each(function () {
|
||
jQuery.removeAttr(this, name)
|
||
})
|
||
}
|
||
});
|
||
jQuery.extend({
|
||
attr: function (elem, name, value) {
|
||
var ret, hooks, nType = elem.nodeType;
|
||
// Don't get/set attributes on text, comment and attribute nodes
|
||
if (nType === 3 || nType === 8 || nType === 2) {
|
||
return
|
||
}
|
||
// Fallback to prop when attributes are not supported
|
||
if (typeof elem.getAttribute === 'undefined') {
|
||
return jQuery.prop(elem, name, value)
|
||
}
|
||
// All attributes are lowercase
|
||
// Grab necessary hook if one is defined
|
||
if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
|
||
name = name.toLowerCase();
|
||
hooks = jQuery.attrHooks[name] || (jQuery.expr.match.bool.test(name) ? boolHook : undefined)
|
||
}
|
||
if (value !== undefined) {
|
||
if (value === null) {
|
||
jQuery.removeAttr(elem, name);
|
||
return
|
||
}
|
||
if (hooks && 'set' in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
|
||
return ret
|
||
}
|
||
elem.setAttribute(name, value + '');
|
||
return value
|
||
}
|
||
if (hooks && 'get' in hooks && (ret = hooks.get(elem, name)) !== null) {
|
||
return ret
|
||
}
|
||
ret = jQuery.find.attr(elem, name);
|
||
// Non-existent attributes return null, we normalize to undefined
|
||
return ret == null ? undefined : ret
|
||
},
|
||
attrHooks: {
|
||
type: {
|
||
set: function (elem, value) {
|
||
if (!support.radioValue && value === 'radio' && jQuery.nodeName(elem, 'input')) {
|
||
var val = elem.value;
|
||
elem.setAttribute('type', value);
|
||
if (val) {
|
||
elem.value = val
|
||
}
|
||
return value
|
||
}
|
||
}
|
||
}
|
||
},
|
||
removeAttr: function (elem, value) {
|
||
var name, propName, i = 0, attrNames = value && value.match(rnotwhite);
|
||
if (attrNames && elem.nodeType === 1) {
|
||
while (name = attrNames[i++]) {
|
||
propName = jQuery.propFix[name] || name;
|
||
// Boolean attributes get special treatment (#10870)
|
||
if (jQuery.expr.match.bool.test(name)) {
|
||
// Set corresponding property to false
|
||
elem[propName] = false
|
||
}
|
||
elem.removeAttribute(name)
|
||
}
|
||
}
|
||
}
|
||
});
|
||
// Hooks for boolean attributes
|
||
boolHook = {
|
||
set: function (elem, value, name) {
|
||
if (value === false) {
|
||
// Remove boolean attributes when set to false
|
||
jQuery.removeAttr(elem, name)
|
||
} else {
|
||
elem.setAttribute(name, name)
|
||
}
|
||
return name
|
||
}
|
||
};
|
||
jQuery.each(jQuery.expr.match.bool.source.match(/\w+/g), function (i, name) {
|
||
var getter = attrHandle[name] || jQuery.find.attr;
|
||
attrHandle[name] = function (elem, name, isXML) {
|
||
var ret, handle;
|
||
if (!isXML) {
|
||
// Avoid an infinite loop by temporarily removing this function from the getter
|
||
handle = attrHandle[name];
|
||
attrHandle[name] = ret;
|
||
ret = getter(elem, name, isXML) != null ? name.toLowerCase() : null;
|
||
attrHandle[name] = handle
|
||
}
|
||
return ret
|
||
}
|
||
});
|
||
var rfocusable = /^(?:input|select|textarea|button)$/i, rclickable = /^(?:a|area)$/i;
|
||
jQuery.fn.extend({
|
||
prop: function (name, value) {
|
||
return access(this, jQuery.prop, name, value, arguments.length > 1)
|
||
},
|
||
removeProp: function (name) {
|
||
return this.each(function () {
|
||
delete this[jQuery.propFix[name] || name]
|
||
})
|
||
}
|
||
});
|
||
jQuery.extend({
|
||
prop: function (elem, name, value) {
|
||
var ret, hooks, nType = elem.nodeType;
|
||
// Don't get/set properties on text, comment and attribute nodes
|
||
if (nType === 3 || nType === 8 || nType === 2) {
|
||
return
|
||
}
|
||
if (nType !== 1 || !jQuery.isXMLDoc(elem)) {
|
||
// Fix name and attach hooks
|
||
name = jQuery.propFix[name] || name;
|
||
hooks = jQuery.propHooks[name]
|
||
}
|
||
if (value !== undefined) {
|
||
if (hooks && 'set' in hooks && (ret = hooks.set(elem, value, name)) !== undefined) {
|
||
return ret
|
||
}
|
||
return elem[name] = value
|
||
}
|
||
if (hooks && 'get' in hooks && (ret = hooks.get(elem, name)) !== null) {
|
||
return ret
|
||
}
|
||
return elem[name]
|
||
},
|
||
propHooks: {
|
||
tabIndex: {
|
||
get: function (elem) {
|
||
// elem.tabIndex doesn't always return the
|
||
// correct value when it hasn't been explicitly set
|
||
// http://fluidproject.org/blog/2008/01/09/getting-setting-and-removing-tabindex-values-with-javascript/
|
||
// Use proper attribute retrieval(#12072)
|
||
var tabindex = jQuery.find.attr(elem, 'tabindex');
|
||
return tabindex ? parseInt(tabindex, 10) : rfocusable.test(elem.nodeName) || rclickable.test(elem.nodeName) && elem.href ? 0 : -1
|
||
}
|
||
}
|
||
},
|
||
propFix: {
|
||
'for': 'htmlFor',
|
||
'class': 'className'
|
||
}
|
||
});
|
||
// Support: IE <=11 only
|
||
// Accessing the selectedIndex property
|
||
// forces the browser to respect setting selected
|
||
// on the option
|
||
// The getter ensures a default option is selected
|
||
// when in an optgroup
|
||
if (!support.optSelected) {
|
||
jQuery.propHooks.selected = {
|
||
get: function (elem) {
|
||
var parent = elem.parentNode;
|
||
if (parent && parent.parentNode) {
|
||
parent.parentNode.selectedIndex
|
||
}
|
||
return null
|
||
},
|
||
set: function (elem) {
|
||
var parent = elem.parentNode;
|
||
if (parent) {
|
||
parent.selectedIndex;
|
||
if (parent.parentNode) {
|
||
parent.parentNode.selectedIndex
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
jQuery.each([
|
||
'tabIndex',
|
||
'readOnly',
|
||
'maxLength',
|
||
'cellSpacing',
|
||
'cellPadding',
|
||
'rowSpan',
|
||
'colSpan',
|
||
'useMap',
|
||
'frameBorder',
|
||
'contentEditable'
|
||
], function () {
|
||
jQuery.propFix[this.toLowerCase()] = this
|
||
});
|
||
var rclass = /[\t\r\n\f]/g;
|
||
function getClass(elem) {
|
||
return elem.getAttribute && elem.getAttribute('class') || ''
|
||
}
|
||
jQuery.fn.extend({
|
||
addClass: function (value) {
|
||
var classes, elem, cur, curValue, clazz, j, finalValue, i = 0;
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function (j) {
|
||
jQuery(this).addClass(value.call(this, j, getClass(this)))
|
||
})
|
||
}
|
||
if (typeof value === 'string' && value) {
|
||
classes = value.match(rnotwhite) || [];
|
||
while (elem = this[i++]) {
|
||
curValue = getClass(elem);
|
||
cur = elem.nodeType === 1 && (' ' + curValue + ' ').replace(rclass, ' ');
|
||
if (cur) {
|
||
j = 0;
|
||
while (clazz = classes[j++]) {
|
||
if (cur.indexOf(' ' + clazz + ' ') < 0) {
|
||
cur += clazz + ' '
|
||
}
|
||
}
|
||
// Only assign if different to avoid unneeded rendering.
|
||
finalValue = jQuery.trim(cur);
|
||
if (curValue !== finalValue) {
|
||
elem.setAttribute('class', finalValue)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return this
|
||
},
|
||
removeClass: function (value) {
|
||
var classes, elem, cur, curValue, clazz, j, finalValue, i = 0;
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function (j) {
|
||
jQuery(this).removeClass(value.call(this, j, getClass(this)))
|
||
})
|
||
}
|
||
if (!arguments.length) {
|
||
return this.attr('class', '')
|
||
}
|
||
if (typeof value === 'string' && value) {
|
||
classes = value.match(rnotwhite) || [];
|
||
while (elem = this[i++]) {
|
||
curValue = getClass(elem);
|
||
// This expression is here for better compressibility (see addClass)
|
||
cur = elem.nodeType === 1 && (' ' + curValue + ' ').replace(rclass, ' ');
|
||
if (cur) {
|
||
j = 0;
|
||
while (clazz = classes[j++]) {
|
||
// Remove *all* instances
|
||
while (cur.indexOf(' ' + clazz + ' ') > -1) {
|
||
cur = cur.replace(' ' + clazz + ' ', ' ')
|
||
}
|
||
}
|
||
// Only assign if different to avoid unneeded rendering.
|
||
finalValue = jQuery.trim(cur);
|
||
if (curValue !== finalValue) {
|
||
elem.setAttribute('class', finalValue)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return this
|
||
},
|
||
toggleClass: function (value, stateVal) {
|
||
var type = typeof value;
|
||
if (typeof stateVal === 'boolean' && type === 'string') {
|
||
return stateVal ? this.addClass(value) : this.removeClass(value)
|
||
}
|
||
if (jQuery.isFunction(value)) {
|
||
return this.each(function (i) {
|
||
jQuery(this).toggleClass(value.call(this, i, getClass(this), stateVal), stateVal)
|
||
})
|
||
}
|
||
return this.each(function () {
|
||
var className, i, self, classNames;
|
||
if (type === 'string') {
|
||
// Toggle individual class names
|
||
i = 0;
|
||
self = jQuery(this);
|
||
classNames = value.match(rnotwhite) || [];
|
||
while (className = classNames[i++]) {
|
||
// Check each className given, space separated list
|
||
if (self.hasClass(className)) {
|
||
self.removeClass(className)
|
||
} else {
|
||
self.addClass(className)
|
||
}
|
||
} // Toggle whole class name
|
||
} else if (value === undefined || type === 'boolean') {
|
||
className = getClass(this);
|
||
if (className) {
|
||
// Store className if set
|
||
dataPriv.set(this, '__className__', className)
|
||
}
|
||
// If the element has a class name or if we're passed `false`,
|
||
// then remove the whole classname (if there was one, the above saved it).
|
||
// Otherwise bring back whatever was previously saved (if anything),
|
||
// falling back to the empty string if nothing was stored.
|
||
if (this.setAttribute) {
|
||
this.setAttribute('class', className || value === false ? '' : dataPriv.get(this, '__className__') || '')
|
||
}
|
||
}
|
||
})
|
||
},
|
||
hasClass: function (selector) {
|
||
var className, elem, i = 0;
|
||
className = ' ' + selector + ' ';
|
||
while (elem = this[i++]) {
|
||
if (elem.nodeType === 1 && (' ' + getClass(elem) + ' ').replace(rclass, ' ').indexOf(className) > -1) {
|
||
return true
|
||
}
|
||
}
|
||
return false
|
||
}
|
||
});
|
||
var rreturn = /\r/g, rspaces = /[\x20\t\r\n\f]+/g;
|
||
jQuery.fn.extend({
|
||
val: function (value) {
|
||
var hooks, ret, isFunction, elem = this[0];
|
||
if (!arguments.length) {
|
||
if (elem) {
|
||
hooks = jQuery.valHooks[elem.type] || jQuery.valHooks[elem.nodeName.toLowerCase()];
|
||
if (hooks && 'get' in hooks && (ret = hooks.get(elem, 'value')) !== undefined) {
|
||
return ret
|
||
}
|
||
ret = elem.value;
|
||
return typeof ret === 'string' ? // Handle most common string cases
|
||
ret.replace(rreturn, '') : // Handle cases where value is null/undef or number
|
||
ret == null ? '' : ret
|
||
}
|
||
return
|
||
}
|
||
isFunction = jQuery.isFunction(value);
|
||
return this.each(function (i) {
|
||
var val;
|
||
if (this.nodeType !== 1) {
|
||
return
|
||
}
|
||
if (isFunction) {
|
||
val = value.call(this, i, jQuery(this).val())
|
||
} else {
|
||
val = value
|
||
}
|
||
// Treat null/undefined as ""; convert numbers to string
|
||
if (val == null) {
|
||
val = ''
|
||
} else if (typeof val === 'number') {
|
||
val += ''
|
||
} else if (jQuery.isArray(val)) {
|
||
val = jQuery.map(val, function (value) {
|
||
return value == null ? '' : value + ''
|
||
})
|
||
}
|
||
hooks = jQuery.valHooks[this.type] || jQuery.valHooks[this.nodeName.toLowerCase()];
|
||
// If set returns undefined, fall back to normal setting
|
||
if (!hooks || !('set' in hooks) || hooks.set(this, val, 'value') === undefined) {
|
||
this.value = val
|
||
}
|
||
})
|
||
}
|
||
});
|
||
jQuery.extend({
|
||
valHooks: {
|
||
option: {
|
||
get: function (elem) {
|
||
var val = jQuery.find.attr(elem, 'value');
|
||
return val != null ? val : // Support: IE10-11+
|
||
// option.text throws exceptions (#14686, #14858)
|
||
// Strip and collapse whitespace
|
||
// https://html.spec.whatwg.org/#strip-and-collapse-whitespace
|
||
jQuery.trim(jQuery.text(elem)).replace(rspaces, ' ')
|
||
}
|
||
},
|
||
select: {
|
||
get: function (elem) {
|
||
var value, option, options = elem.options, index = elem.selectedIndex, one = elem.type === 'select-one' || index < 0, values = one ? null : [], max = one ? index + 1 : options.length, i = index < 0 ? max : one ? index : 0;
|
||
// Loop through all the selected options
|
||
for (; i < max; i++) {
|
||
option = options[i];
|
||
// IE8-9 doesn't update selected after form reset (#2551)
|
||
if ((option.selected || i === index) && (support.optDisabled ? !option.disabled : option.getAttribute('disabled') === null) && (!option.parentNode.disabled || !jQuery.nodeName(option.parentNode, 'optgroup'))) {
|
||
// Get the specific value for the option
|
||
value = jQuery(option).val();
|
||
// We don't need an array for one selects
|
||
if (one) {
|
||
return value
|
||
}
|
||
// Multi-Selects return an array
|
||
values.push(value)
|
||
}
|
||
}
|
||
return values
|
||
},
|
||
set: function (elem, value) {
|
||
var optionSet, option, options = elem.options, values = jQuery.makeArray(value), i = options.length;
|
||
while (i--) {
|
||
option = options[i];
|
||
if (option.selected = jQuery.inArray(jQuery.valHooks.option.get(option), values) > -1) {
|
||
optionSet = true
|
||
}
|
||
}
|
||
// Force browsers to behave consistently when non-matching value is set
|
||
if (!optionSet) {
|
||
elem.selectedIndex = -1
|
||
}
|
||
return values
|
||
}
|
||
}
|
||
}
|
||
});
|
||
// Radios and checkboxes getter/setter
|
||
jQuery.each([
|
||
'radio',
|
||
'checkbox'
|
||
], function () {
|
||
jQuery.valHooks[this] = {
|
||
set: function (elem, value) {
|
||
if (jQuery.isArray(value)) {
|
||
return elem.checked = jQuery.inArray(jQuery(elem).val(), value) > -1
|
||
}
|
||
}
|
||
};
|
||
if (!support.checkOn) {
|
||
jQuery.valHooks[this].get = function (elem) {
|
||
return elem.getAttribute('value') === null ? 'on' : elem.value
|
||
}
|
||
}
|
||
});
|
||
// Return jQuery for attributes-only inclusion
|
||
var rfocusMorph = /^(?:focusinfocus|focusoutblur)$/;
|
||
jQuery.extend(jQuery.event, {
|
||
trigger: function (event, data, elem, onlyHandlers) {
|
||
var i, cur, tmp, bubbleType, ontype, handle, special, eventPath = [elem || document], type = hasOwn.call(event, 'type') ? event.type : event, namespaces = hasOwn.call(event, 'namespace') ? event.namespace.split('.') : [];
|
||
cur = tmp = elem = elem || document;
|
||
// Don't do events on text and comment nodes
|
||
if (elem.nodeType === 3 || elem.nodeType === 8) {
|
||
return
|
||
}
|
||
// focus/blur morphs to focusin/out; ensure we're not firing them right now
|
||
if (rfocusMorph.test(type + jQuery.event.triggered)) {
|
||
return
|
||
}
|
||
if (type.indexOf('.') > -1) {
|
||
// Namespaced trigger; create a regexp to match event type in handle()
|
||
namespaces = type.split('.');
|
||
type = namespaces.shift();
|
||
namespaces.sort()
|
||
}
|
||
ontype = type.indexOf(':') < 0 && 'on' + type;
|
||
// Caller can pass in a jQuery.Event object, Object, or just an event type string
|
||
event = event[jQuery.expando] ? event : new jQuery.Event(type, typeof event === 'object' && event);
|
||
// Trigger bitmask: & 1 for native handlers; & 2 for jQuery (always true)
|
||
event.isTrigger = onlyHandlers ? 2 : 3;
|
||
event.namespace = namespaces.join('.');
|
||
event.rnamespace = event.namespace ? new RegExp('(^|\\.)' + namespaces.join('\\.(?:.*\\.|)') + '(\\.|$)') : null;
|
||
// Clean up the event in case it is being reused
|
||
event.result = undefined;
|
||
if (!event.target) {
|
||
event.target = elem
|
||
}
|
||
// Clone any incoming data and prepend the event, creating the handler arg list
|
||
data = data == null ? [event] : jQuery.makeArray(data, [event]);
|
||
// Allow special events to draw outside the lines
|
||
special = jQuery.event.special[type] || {};
|
||
if (!onlyHandlers && special.trigger && special.trigger.apply(elem, data) === false) {
|
||
return
|
||
}
|
||
// Determine event propagation path in advance, per W3C events spec (#9951)
|
||
// Bubble up to document, then to window; watch for a global ownerDocument var (#9724)
|
||
if (!onlyHandlers && !special.noBubble && !jQuery.isWindow(elem)) {
|
||
bubbleType = special.delegateType || type;
|
||
if (!rfocusMorph.test(bubbleType + type)) {
|
||
cur = cur.parentNode
|
||
}
|
||
for (; cur; cur = cur.parentNode) {
|
||
eventPath.push(cur);
|
||
tmp = cur
|
||
}
|
||
// Only add window if we got to document (e.g., not plain obj or detached DOM)
|
||
if (tmp === (elem.ownerDocument || document)) {
|
||
eventPath.push(tmp.defaultView || tmp.parentWindow || window)
|
||
}
|
||
}
|
||
// Fire handlers on the event path
|
||
i = 0;
|
||
while ((cur = eventPath[i++]) && !event.isPropagationStopped()) {
|
||
event.type = i > 1 ? bubbleType : special.bindType || type;
|
||
// jQuery handler
|
||
handle = (dataPriv.get(cur, 'events') || {})[event.type] && dataPriv.get(cur, 'handle');
|
||
if (handle) {
|
||
handle.apply(cur, data)
|
||
}
|
||
// Native handler
|
||
handle = ontype && cur[ontype];
|
||
if (handle && handle.apply && acceptData(cur)) {
|
||
event.result = handle.apply(cur, data);
|
||
if (event.result === false) {
|
||
event.preventDefault()
|
||
}
|
||
}
|
||
}
|
||
event.type = type;
|
||
// If nobody prevented the default action, do it now
|
||
if (!onlyHandlers && !event.isDefaultPrevented()) {
|
||
if ((!special._default || special._default.apply(eventPath.pop(), data) === false) && acceptData(elem)) {
|
||
// Call a native DOM method on the target with the same name name as the event.
|
||
// Don't do default actions on window, that's where global variables be (#6170)
|
||
if (ontype && jQuery.isFunction(elem[type]) && !jQuery.isWindow(elem)) {
|
||
// Don't re-trigger an onFOO event when we call its FOO() method
|
||
tmp = elem[ontype];
|
||
if (tmp) {
|
||
elem[ontype] = null
|
||
}
|
||
// Prevent re-triggering of the same event, since we already bubbled it above
|
||
jQuery.event.triggered = type;
|
||
elem[type]();
|
||
jQuery.event.triggered = undefined;
|
||
if (tmp) {
|
||
elem[ontype] = tmp
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return event.result
|
||
},
|
||
// Piggyback on a donor event to simulate a different one
|
||
simulate: function (type, elem, event) {
|
||
var e = jQuery.extend(new jQuery.Event, event, {
|
||
type: type,
|
||
isSimulated: true // Previously, `originalEvent: {}` was set here, so stopPropagation call
|
||
// would not be triggered on donor event, since in our own
|
||
// jQuery.event.stopPropagation function we had a check for existence of
|
||
// originalEvent.stopPropagation method, so, consequently it would be a noop.
|
||
//
|
||
// But now, this "simulate" function is used only for events
|
||
// for which stopPropagation() is noop, so there is no need for that anymore.
|
||
//
|
||
// For the 1.x branch though, guard for "click" and "submit"
|
||
// events is still used, but was moved to jQuery.event.stopPropagation function
|
||
// because `originalEvent` should point to the original event for the constancy
|
||
// with other events and for more focused logic
|
||
});
|
||
jQuery.event.trigger(e, null, elem);
|
||
if (e.isDefaultPrevented()) {
|
||
event.preventDefault()
|
||
}
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
trigger: function (type, data) {
|
||
return this.each(function () {
|
||
jQuery.event.trigger(type, data, this)
|
||
})
|
||
},
|
||
triggerHandler: function (type, data) {
|
||
var elem = this[0];
|
||
if (elem) {
|
||
return jQuery.event.trigger(type, data, elem, true)
|
||
}
|
||
}
|
||
});
|
||
jQuery.each(('blur focus focusin focusout load resize scroll unload click dblclick ' + 'mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave ' + 'change select submit keydown keypress keyup error contextmenu').split(' '), function (i, name) {
|
||
// Handle event binding
|
||
jQuery.fn[name] = function (data, fn) {
|
||
return arguments.length > 0 ? this.on(name, null, data, fn) : this.trigger(name)
|
||
}
|
||
});
|
||
jQuery.fn.extend({
|
||
hover: function (fnOver, fnOut) {
|
||
return this.mouseenter(fnOver).mouseleave(fnOut || fnOver)
|
||
}
|
||
});
|
||
support.focusin = 'onfocusin' in window;
|
||
// Support: Firefox
|
||
// Firefox doesn't have focus(in | out) events
|
||
// Related ticket - https://bugzilla.mozilla.org/show_bug.cgi?id=687787
|
||
//
|
||
// Support: Chrome, Safari
|
||
// focus(in | out) events fire after focus & blur events,
|
||
// which is spec violation - http://www.w3.org/TR/DOM-Level-3-Events/#events-focusevent-event-order
|
||
// Related ticket - https://code.google.com/p/chromium/issues/detail?id=449857
|
||
if (!support.focusin) {
|
||
jQuery.each({
|
||
focus: 'focusin',
|
||
blur: 'focusout'
|
||
}, function (orig, fix) {
|
||
// Attach a single capturing handler on the document while someone wants focusin/focusout
|
||
var handler = function (event) {
|
||
jQuery.event.simulate(fix, event.target, jQuery.event.fix(event))
|
||
};
|
||
jQuery.event.special[fix] = {
|
||
setup: function () {
|
||
var doc = this.ownerDocument || this, attaches = dataPriv.access(doc, fix);
|
||
if (!attaches) {
|
||
doc.addEventListener(orig, handler, true)
|
||
}
|
||
dataPriv.access(doc, fix, (attaches || 0) + 1)
|
||
},
|
||
teardown: function () {
|
||
var doc = this.ownerDocument || this, attaches = dataPriv.access(doc, fix) - 1;
|
||
if (!attaches) {
|
||
doc.removeEventListener(orig, handler, true);
|
||
dataPriv.remove(doc, fix)
|
||
} else {
|
||
dataPriv.access(doc, fix, attaches)
|
||
}
|
||
}
|
||
}
|
||
})
|
||
}
|
||
var location = window.location;
|
||
var nonce = jQuery.now();
|
||
var rquery = /\?/;
|
||
// Support: Android 2.3
|
||
// Workaround failure to string-cast null input
|
||
jQuery.parseJSON = function (data) {
|
||
return JSON.parse(data + '')
|
||
};
|
||
// Cross-browser xml parsing
|
||
jQuery.parseXML = function (data) {
|
||
var xml;
|
||
if (!data || typeof data !== 'string') {
|
||
return null
|
||
}
|
||
// Support: IE9
|
||
try {
|
||
xml = new window.DOMParser().parseFromString(data, 'text/xml')
|
||
} catch (e) {
|
||
xml = undefined
|
||
}
|
||
if (!xml || xml.getElementsByTagName('parsererror').length) {
|
||
jQuery.error('Invalid XML: ' + data)
|
||
}
|
||
return xml
|
||
};
|
||
var rhash = /#.*$/, rts = /([?&])_=[^&]*/, rheaders = /^(.*?):[ \t]*([^\r\n]*)$/gm,
|
||
// #7653, #8125, #8152: local protocol detection
|
||
rlocalProtocol = /^(?:about|app|app-storage|.+-extension|file|res|widget):$/, rnoContent = /^(?:GET|HEAD)$/, rprotocol = /^\/\//,
|
||
/* Prefilters
|
||
* 1) They are useful to introduce custom dataTypes (see ajax/jsonp.js for an example)
|
||
* 2) These are called:
|
||
* - BEFORE asking for a transport
|
||
* - AFTER param serialization (s.data is a string if s.processData is true)
|
||
* 3) key is the dataType
|
||
* 4) the catchall symbol "*" can be used
|
||
* 5) execution will start with transport dataType and THEN continue down to "*" if needed
|
||
*/
|
||
prefilters = {},
|
||
/* Transports bindings
|
||
* 1) key is the dataType
|
||
* 2) the catchall symbol "*" can be used
|
||
* 3) selection will start with transport dataType and THEN go to "*" if needed
|
||
*/
|
||
transports = {},
|
||
// Avoid comment-prolog char sequence (#10098); must appease lint and evade compression
|
||
allTypes = '*/'.concat('*'),
|
||
// Anchor tag for parsing the document origin
|
||
originAnchor = document.createElement('a');
|
||
originAnchor.href = location.href;
|
||
// Base "constructor" for jQuery.ajaxPrefilter and jQuery.ajaxTransport
|
||
function addToPrefiltersOrTransports(structure) {
|
||
// dataTypeExpression is optional and defaults to "*"
|
||
return function (dataTypeExpression, func) {
|
||
if (typeof dataTypeExpression !== 'string') {
|
||
func = dataTypeExpression;
|
||
dataTypeExpression = '*'
|
||
}
|
||
var dataType, i = 0, dataTypes = dataTypeExpression.toLowerCase().match(rnotwhite) || [];
|
||
if (jQuery.isFunction(func)) {
|
||
// For each dataType in the dataTypeExpression
|
||
while (dataType = dataTypes[i++]) {
|
||
// Prepend if requested
|
||
if (dataType[0] === '+') {
|
||
dataType = dataType.slice(1) || '*';
|
||
(structure[dataType] = structure[dataType] || []).unshift(func) // Otherwise append
|
||
} else {
|
||
(structure[dataType] = structure[dataType] || []).push(func)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Base inspection function for prefilters and transports
|
||
function inspectPrefiltersOrTransports(structure, options, originalOptions, jqXHR) {
|
||
var inspected = {}, seekingTransport = structure === transports;
|
||
function inspect(dataType) {
|
||
var selected;
|
||
inspected[dataType] = true;
|
||
jQuery.each(structure[dataType] || [], function (_, prefilterOrFactory) {
|
||
var dataTypeOrTransport = prefilterOrFactory(options, originalOptions, jqXHR);
|
||
if (typeof dataTypeOrTransport === 'string' && !seekingTransport && !inspected[dataTypeOrTransport]) {
|
||
options.dataTypes.unshift(dataTypeOrTransport);
|
||
inspect(dataTypeOrTransport);
|
||
return false
|
||
} else if (seekingTransport) {
|
||
return !(selected = dataTypeOrTransport)
|
||
}
|
||
});
|
||
return selected
|
||
}
|
||
return inspect(options.dataTypes[0]) || !inspected['*'] && inspect('*')
|
||
}
|
||
// A special extend for ajax options
|
||
// that takes "flat" options (not to be deep extended)
|
||
// Fixes #9887
|
||
function ajaxExtend(target, src) {
|
||
var key, deep, flatOptions = jQuery.ajaxSettings.flatOptions || {};
|
||
for (key in src) {
|
||
if (src[key] !== undefined) {
|
||
(flatOptions[key] ? target : deep || (deep = {}))[key] = src[key]
|
||
}
|
||
}
|
||
if (deep) {
|
||
jQuery.extend(true, target, deep)
|
||
}
|
||
return target
|
||
}
|
||
/* Handles responses to an ajax request:
|
||
* - finds the right dataType (mediates between content-type and expected dataType)
|
||
* - returns the corresponding response
|
||
*/
|
||
function ajaxHandleResponses(s, jqXHR, responses) {
|
||
var ct, type, finalDataType, firstDataType, contents = s.contents, dataTypes = s.dataTypes;
|
||
// Remove auto dataType and get content-type in the process
|
||
while (dataTypes[0] === '*') {
|
||
dataTypes.shift();
|
||
if (ct === undefined) {
|
||
ct = s.mimeType || jqXHR.getResponseHeader('Content-Type')
|
||
}
|
||
}
|
||
// Check if we're dealing with a known content-type
|
||
if (ct) {
|
||
for (type in contents) {
|
||
if (contents[type] && contents[type].test(ct)) {
|
||
dataTypes.unshift(type);
|
||
break
|
||
}
|
||
}
|
||
}
|
||
// Check to see if we have a response for the expected dataType
|
||
if (dataTypes[0] in responses) {
|
||
finalDataType = dataTypes[0]
|
||
} else {
|
||
// Try convertible dataTypes
|
||
for (type in responses) {
|
||
if (!dataTypes[0] || s.converters[type + ' ' + dataTypes[0]]) {
|
||
finalDataType = type;
|
||
break
|
||
}
|
||
if (!firstDataType) {
|
||
firstDataType = type
|
||
}
|
||
}
|
||
// Or just use first one
|
||
finalDataType = finalDataType || firstDataType
|
||
}
|
||
// If we found a dataType
|
||
// We add the dataType to the list if needed
|
||
// and return the corresponding response
|
||
if (finalDataType) {
|
||
if (finalDataType !== dataTypes[0]) {
|
||
dataTypes.unshift(finalDataType)
|
||
}
|
||
return responses[finalDataType]
|
||
}
|
||
}
|
||
/* Chain conversions given the request and the original response
|
||
* Also sets the responseXXX fields on the jqXHR instance
|
||
*/
|
||
function ajaxConvert(s, response, jqXHR, isSuccess) {
|
||
var conv2, current, conv, tmp, prev, converters = {},
|
||
// Work with a copy of dataTypes in case we need to modify it for conversion
|
||
dataTypes = s.dataTypes.slice();
|
||
// Create converters map with lowercased keys
|
||
if (dataTypes[1]) {
|
||
for (conv in s.converters) {
|
||
converters[conv.toLowerCase()] = s.converters[conv]
|
||
}
|
||
}
|
||
current = dataTypes.shift();
|
||
// Convert to each sequential dataType
|
||
while (current) {
|
||
if (s.responseFields[current]) {
|
||
jqXHR[s.responseFields[current]] = response
|
||
}
|
||
// Apply the dataFilter if provided
|
||
if (!prev && isSuccess && s.dataFilter) {
|
||
response = s.dataFilter(response, s.dataType)
|
||
}
|
||
prev = current;
|
||
current = dataTypes.shift();
|
||
if (current) {
|
||
// There's only work to do if current dataType is non-auto
|
||
if (current === '*') {
|
||
current = prev // Convert response if prev dataType is non-auto and differs from current
|
||
} else if (prev !== '*' && prev !== current) {
|
||
// Seek a direct converter
|
||
conv = converters[prev + ' ' + current] || converters['* ' + current];
|
||
// If none found, seek a pair
|
||
if (!conv) {
|
||
for (conv2 in converters) {
|
||
// If conv2 outputs current
|
||
tmp = conv2.split(' ');
|
||
if (tmp[1] === current) {
|
||
// If prev can be converted to accepted input
|
||
conv = converters[prev + ' ' + tmp[0]] || converters['* ' + tmp[0]];
|
||
if (conv) {
|
||
// Condense equivalence converters
|
||
if (conv === true) {
|
||
conv = converters[conv2] // Otherwise, insert the intermediate dataType
|
||
} else if (converters[conv2] !== true) {
|
||
current = tmp[0];
|
||
dataTypes.unshift(tmp[1])
|
||
}
|
||
break
|
||
}
|
||
}
|
||
}
|
||
}
|
||
// Apply converter (if not an equivalence)
|
||
if (conv !== true) {
|
||
// Unless errors are allowed to bubble, catch and return them
|
||
if (conv && s.throws) {
|
||
response = conv(response)
|
||
} else {
|
||
try {
|
||
response = conv(response)
|
||
} catch (e) {
|
||
return {
|
||
state: 'parsererror',
|
||
error: conv ? e : 'No conversion from ' + prev + ' to ' + current
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return {
|
||
state: 'success',
|
||
data: response
|
||
}
|
||
}
|
||
jQuery.extend({
|
||
// Counter for holding the number of active queries
|
||
active: 0,
|
||
// Last-Modified header cache for next request
|
||
lastModified: {},
|
||
etag: {},
|
||
ajaxSettings: {
|
||
url: location.href,
|
||
type: 'GET',
|
||
isLocal: rlocalProtocol.test(location.protocol),
|
||
global: true,
|
||
processData: true,
|
||
async: true,
|
||
contentType: 'application/x-www-form-urlencoded; charset=UTF-8',
|
||
/*
|
||
timeout: 0,
|
||
data: null,
|
||
dataType: null,
|
||
username: null,
|
||
password: null,
|
||
cache: null,
|
||
throws: false,
|
||
traditional: false,
|
||
headers: {},
|
||
*/
|
||
accepts: {
|
||
'*': allTypes,
|
||
text: 'text/plain',
|
||
html: 'text/html',
|
||
xml: 'application/xml, text/xml',
|
||
json: 'application/json, text/javascript'
|
||
},
|
||
contents: {
|
||
xml: /\bxml\b/,
|
||
html: /\bhtml/,
|
||
json: /\bjson\b/
|
||
},
|
||
responseFields: {
|
||
xml: 'responseXML',
|
||
text: 'responseText',
|
||
json: 'responseJSON'
|
||
},
|
||
// Data converters
|
||
// Keys separate source (or catchall "*") and destination types with a single space
|
||
converters: {
|
||
// Convert anything to text
|
||
'* text': String,
|
||
// Text to html (true = no transformation)
|
||
'text html': true,
|
||
// Evaluate text as a json expression
|
||
'text json': jQuery.parseJSON,
|
||
// Parse text as xml
|
||
'text xml': jQuery.parseXML
|
||
},
|
||
// For options that shouldn't be deep extended:
|
||
// you can add your own custom options here if
|
||
// and when you create one that shouldn't be
|
||
// deep extended (see ajaxExtend)
|
||
flatOptions: {
|
||
url: true,
|
||
context: true
|
||
}
|
||
},
|
||
// Creates a full fledged settings object into target
|
||
// with both ajaxSettings and settings fields.
|
||
// If target is omitted, writes into ajaxSettings.
|
||
ajaxSetup: function (target, settings) {
|
||
return settings ? // Building a settings object
|
||
ajaxExtend(ajaxExtend(target, jQuery.ajaxSettings), settings) : // Extending ajaxSettings
|
||
ajaxExtend(jQuery.ajaxSettings, target)
|
||
},
|
||
ajaxPrefilter: addToPrefiltersOrTransports(prefilters),
|
||
ajaxTransport: addToPrefiltersOrTransports(transports),
|
||
// Main method
|
||
ajax: function (url, options) {
|
||
// If url is an object, simulate pre-1.5 signature
|
||
if (typeof url === 'object') {
|
||
options = url;
|
||
url = undefined
|
||
}
|
||
// Force options to be an object
|
||
options = options || {};
|
||
var transport,
|
||
// URL without anti-cache param
|
||
cacheURL,
|
||
// Response headers
|
||
responseHeadersString, responseHeaders,
|
||
// timeout handle
|
||
timeoutTimer,
|
||
// Url cleanup var
|
||
urlAnchor,
|
||
// To know if global events are to be dispatched
|
||
fireGlobals,
|
||
// Loop variable
|
||
i,
|
||
// Create the final options object
|
||
s = jQuery.ajaxSetup({}, options),
|
||
// Callbacks context
|
||
callbackContext = s.context || s,
|
||
// Context for global events is callbackContext if it is a DOM node or jQuery collection
|
||
globalEventContext = s.context && (callbackContext.nodeType || callbackContext.jquery) ? jQuery(callbackContext) : jQuery.event,
|
||
// Deferreds
|
||
deferred = jQuery.Deferred(), completeDeferred = jQuery.Callbacks('once memory'),
|
||
// Status-dependent callbacks
|
||
statusCode = s.statusCode || {},
|
||
// Headers (they are sent all at once)
|
||
requestHeaders = {}, requestHeadersNames = {},
|
||
// The jqXHR state
|
||
state = 0,
|
||
// Default abort message
|
||
strAbort = 'canceled',
|
||
// Fake xhr
|
||
jqXHR = {
|
||
readyState: 0,
|
||
// Builds headers hashtable if needed
|
||
getResponseHeader: function (key) {
|
||
var match;
|
||
if (state === 2) {
|
||
if (!responseHeaders) {
|
||
responseHeaders = {};
|
||
while (match = rheaders.exec(responseHeadersString)) {
|
||
responseHeaders[match[1].toLowerCase()] = match[2]
|
||
}
|
||
}
|
||
match = responseHeaders[key.toLowerCase()]
|
||
}
|
||
return match == null ? null : match
|
||
},
|
||
// Raw string
|
||
getAllResponseHeaders: function () {
|
||
return state === 2 ? responseHeadersString : null
|
||
},
|
||
// Caches the header
|
||
setRequestHeader: function (name, value) {
|
||
var lname = name.toLowerCase();
|
||
if (!state) {
|
||
name = requestHeadersNames[lname] = requestHeadersNames[lname] || name;
|
||
requestHeaders[name] = value
|
||
}
|
||
return this
|
||
},
|
||
// Overrides response content-type header
|
||
overrideMimeType: function (type) {
|
||
if (!state) {
|
||
s.mimeType = type
|
||
}
|
||
return this
|
||
},
|
||
// Status-dependent callbacks
|
||
statusCode: function (map) {
|
||
var code;
|
||
if (map) {
|
||
if (state < 2) {
|
||
for (code in map) {
|
||
// Lazy-add the new callback in a way that preserves old ones
|
||
statusCode[code] = [
|
||
statusCode[code],
|
||
map[code]
|
||
]
|
||
}
|
||
} else {
|
||
// Execute the appropriate callbacks
|
||
jqXHR.always(map[jqXHR.status])
|
||
}
|
||
}
|
||
return this
|
||
},
|
||
// Cancel the request
|
||
abort: function (statusText) {
|
||
var finalText = statusText || strAbort;
|
||
if (transport) {
|
||
transport.abort(finalText)
|
||
}
|
||
done(0, finalText);
|
||
return this
|
||
}
|
||
};
|
||
// Attach deferreds
|
||
deferred.promise(jqXHR).complete = completeDeferred.add;
|
||
jqXHR.success = jqXHR.done;
|
||
jqXHR.error = jqXHR.fail;
|
||
// Remove hash character (#7531: and string promotion)
|
||
// Add protocol if not provided (prefilters might expect it)
|
||
// Handle falsy url in the settings object (#10093: consistency with old signature)
|
||
// We also use the url parameter if available
|
||
s.url = ((url || s.url || location.href) + '').replace(rhash, '').replace(rprotocol, location.protocol + '//');
|
||
// Alias method option to type as per ticket #12004
|
||
s.type = options.method || options.type || s.method || s.type;
|
||
// Extract dataTypes list
|
||
s.dataTypes = jQuery.trim(s.dataType || '*').toLowerCase().match(rnotwhite) || [''];
|
||
// A cross-domain request is in order when the origin doesn't match the current origin.
|
||
if (s.crossDomain == null) {
|
||
urlAnchor = document.createElement('a');
|
||
// Support: IE8-11+
|
||
// IE throws exception if url is malformed, e.g. http://example.com:80x/
|
||
try {
|
||
urlAnchor.href = s.url;
|
||
// Support: IE8-11+
|
||
// Anchor's host property isn't correctly set when s.url is relative
|
||
urlAnchor.href = urlAnchor.href;
|
||
s.crossDomain = originAnchor.protocol + '//' + originAnchor.host !== urlAnchor.protocol + '//' + urlAnchor.host
|
||
} catch (e) {
|
||
// If there is an error parsing the URL, assume it is crossDomain,
|
||
// it can be rejected by the transport if it is invalid
|
||
s.crossDomain = true
|
||
}
|
||
}
|
||
// Convert data if not already a string
|
||
if (s.data && s.processData && typeof s.data !== 'string') {
|
||
s.data = jQuery.param(s.data, s.traditional)
|
||
}
|
||
// Apply prefilters
|
||
inspectPrefiltersOrTransports(prefilters, s, options, jqXHR);
|
||
// If request was aborted inside a prefilter, stop there
|
||
if (state === 2) {
|
||
return jqXHR
|
||
}
|
||
// We can fire global events as of now if asked to
|
||
// Don't fire events if jQuery.event is undefined in an AMD-usage scenario (#15118)
|
||
fireGlobals = jQuery.event && s.global;
|
||
// Watch for a new set of requests
|
||
if (fireGlobals && jQuery.active++ === 0) {
|
||
jQuery.event.trigger('ajaxStart')
|
||
}
|
||
// Uppercase the type
|
||
s.type = s.type.toUpperCase();
|
||
// Determine if request has content
|
||
s.hasContent = !rnoContent.test(s.type);
|
||
// Save the URL in case we're toying with the If-Modified-Since
|
||
// and/or If-None-Match header later on
|
||
cacheURL = s.url;
|
||
// More options handling for requests with no content
|
||
if (!s.hasContent) {
|
||
// If data is available, append data to url
|
||
if (s.data) {
|
||
cacheURL = s.url += (rquery.test(cacheURL) ? '&' : '?') + s.data;
|
||
// #9682: remove data so that it's not used in an eventual retry
|
||
delete s.data
|
||
}
|
||
// Add anti-cache in url if needed
|
||
if (s.cache === false) {
|
||
s.url = rts.test(cacheURL) ? // If there is already a '_' parameter, set its value
|
||
cacheURL.replace(rts, '$1_=' + nonce++) : // Otherwise add one to the end
|
||
cacheURL + (rquery.test(cacheURL) ? '&' : '?') + '_=' + nonce++
|
||
}
|
||
}
|
||
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
||
if (s.ifModified) {
|
||
if (jQuery.lastModified[cacheURL]) {
|
||
jqXHR.setRequestHeader('If-Modified-Since', jQuery.lastModified[cacheURL])
|
||
}
|
||
if (jQuery.etag[cacheURL]) {
|
||
jqXHR.setRequestHeader('If-None-Match', jQuery.etag[cacheURL])
|
||
}
|
||
}
|
||
// Set the correct header, if data is being sent
|
||
if (s.data && s.hasContent && s.contentType !== false || options.contentType) {
|
||
jqXHR.setRequestHeader('Content-Type', s.contentType)
|
||
}
|
||
// Set the Accepts header for the server, depending on the dataType
|
||
jqXHR.setRequestHeader('Accept', s.dataTypes[0] && s.accepts[s.dataTypes[0]] ? s.accepts[s.dataTypes[0]] + (s.dataTypes[0] !== '*' ? ', ' + allTypes + '; q=0.01' : '') : s.accepts['*']);
|
||
// Check for headers option
|
||
for (i in s.headers) {
|
||
jqXHR.setRequestHeader(i, s.headers[i])
|
||
}
|
||
// Allow custom headers/mimetypes and early abort
|
||
if (s.beforeSend && (s.beforeSend.call(callbackContext, jqXHR, s) === false || state === 2)) {
|
||
// Abort if not done already and return
|
||
return jqXHR.abort()
|
||
}
|
||
// Aborting is no longer a cancellation
|
||
strAbort = 'abort';
|
||
// Install callbacks on deferreds
|
||
for (i in {
|
||
success: 1,
|
||
error: 1,
|
||
complete: 1
|
||
}) {
|
||
jqXHR[i](s[i])
|
||
}
|
||
// Get transport
|
||
transport = inspectPrefiltersOrTransports(transports, s, options, jqXHR);
|
||
// If no transport, we auto-abort
|
||
if (!transport) {
|
||
done(-1, 'No Transport')
|
||
} else {
|
||
jqXHR.readyState = 1;
|
||
// Send global event
|
||
if (fireGlobals) {
|
||
globalEventContext.trigger('ajaxSend', [
|
||
jqXHR,
|
||
s
|
||
])
|
||
}
|
||
// If request was aborted inside ajaxSend, stop there
|
||
if (state === 2) {
|
||
return jqXHR
|
||
}
|
||
// Timeout
|
||
if (s.async && s.timeout > 0) {
|
||
timeoutTimer = window.setTimeout(function () {
|
||
jqXHR.abort('timeout')
|
||
}, s.timeout)
|
||
}
|
||
try {
|
||
state = 1;
|
||
transport.send(requestHeaders, done)
|
||
} catch (e) {
|
||
// Propagate exception as error if not done
|
||
if (state < 2) {
|
||
done(-1, e) // Simply rethrow otherwise
|
||
} else {
|
||
throw e
|
||
}
|
||
}
|
||
}
|
||
// Callback for when everything is done
|
||
function done(status, nativeStatusText, responses, headers) {
|
||
var isSuccess, success, error, response, modified, statusText = nativeStatusText;
|
||
// Called once
|
||
if (state === 2) {
|
||
return
|
||
}
|
||
// State is "done" now
|
||
state = 2;
|
||
// Clear timeout if it exists
|
||
if (timeoutTimer) {
|
||
window.clearTimeout(timeoutTimer)
|
||
}
|
||
// Dereference transport for early garbage collection
|
||
// (no matter how long the jqXHR object will be used)
|
||
transport = undefined;
|
||
// Cache response headers
|
||
responseHeadersString = headers || '';
|
||
// Set readyState
|
||
jqXHR.readyState = status > 0 ? 4 : 0;
|
||
// Determine if successful
|
||
isSuccess = status >= 200 && status < 300 || status === 304;
|
||
// Get response data
|
||
if (responses) {
|
||
response = ajaxHandleResponses(s, jqXHR, responses)
|
||
}
|
||
// Convert no matter what (that way responseXXX fields are always set)
|
||
response = ajaxConvert(s, response, jqXHR, isSuccess);
|
||
// If successful, handle type chaining
|
||
if (isSuccess) {
|
||
// Set the If-Modified-Since and/or If-None-Match header, if in ifModified mode.
|
||
if (s.ifModified) {
|
||
modified = jqXHR.getResponseHeader('Last-Modified');
|
||
if (modified) {
|
||
jQuery.lastModified[cacheURL] = modified
|
||
}
|
||
modified = jqXHR.getResponseHeader('etag');
|
||
if (modified) {
|
||
jQuery.etag[cacheURL] = modified
|
||
}
|
||
}
|
||
// if no content
|
||
if (status === 204 || s.type === 'HEAD') {
|
||
statusText = 'nocontent' // if not modified
|
||
} else if (status === 304) {
|
||
statusText = 'notmodified' // If we have data, let's convert it
|
||
} else {
|
||
statusText = response.state;
|
||
success = response.data;
|
||
error = response.error;
|
||
isSuccess = !error
|
||
}
|
||
} else {
|
||
// Extract error from statusText and normalize for non-aborts
|
||
error = statusText;
|
||
if (status || !statusText) {
|
||
statusText = 'error';
|
||
if (status < 0) {
|
||
status = 0
|
||
}
|
||
}
|
||
}
|
||
// Set data for the fake xhr object
|
||
jqXHR.status = status;
|
||
jqXHR.statusText = (nativeStatusText || statusText) + '';
|
||
// Success/Error
|
||
if (isSuccess) {
|
||
deferred.resolveWith(callbackContext, [
|
||
success,
|
||
statusText,
|
||
jqXHR
|
||
])
|
||
} else {
|
||
deferred.rejectWith(callbackContext, [
|
||
jqXHR,
|
||
statusText,
|
||
error
|
||
])
|
||
}
|
||
// Status-dependent callbacks
|
||
jqXHR.statusCode(statusCode);
|
||
statusCode = undefined;
|
||
if (fireGlobals) {
|
||
globalEventContext.trigger(isSuccess ? 'ajaxSuccess' : 'ajaxError', [
|
||
jqXHR,
|
||
s,
|
||
isSuccess ? success : error
|
||
])
|
||
}
|
||
// Complete
|
||
completeDeferred.fireWith(callbackContext, [
|
||
jqXHR,
|
||
statusText
|
||
]);
|
||
if (fireGlobals) {
|
||
globalEventContext.trigger('ajaxComplete', [
|
||
jqXHR,
|
||
s
|
||
]);
|
||
// Handle the global AJAX counter
|
||
if (!--jQuery.active) {
|
||
jQuery.event.trigger('ajaxStop')
|
||
}
|
||
}
|
||
}
|
||
return jqXHR
|
||
},
|
||
getJSON: function (url, data, callback) {
|
||
return jQuery.get(url, data, callback, 'json')
|
||
},
|
||
getScript: function (url, callback) {
|
||
return jQuery.get(url, undefined, callback, 'script')
|
||
}
|
||
});
|
||
jQuery.each([
|
||
'get',
|
||
'post'
|
||
], function (i, method) {
|
||
jQuery[method] = function (url, data, callback, type) {
|
||
// Shift arguments if data argument was omitted
|
||
if (jQuery.isFunction(data)) {
|
||
type = type || callback;
|
||
callback = data;
|
||
data = undefined
|
||
}
|
||
// The url can be an options object (which then must have .url)
|
||
return jQuery.ajax(jQuery.extend({
|
||
url: url,
|
||
type: method,
|
||
dataType: type,
|
||
data: data,
|
||
success: callback
|
||
}, jQuery.isPlainObject(url) && url))
|
||
}
|
||
});
|
||
jQuery._evalUrl = function (url) {
|
||
return jQuery.ajax({
|
||
url: url,
|
||
// Make this explicit, since user can override this through ajaxSetup (#11264)
|
||
type: 'GET',
|
||
dataType: 'script',
|
||
async: false,
|
||
global: false,
|
||
'throws': true
|
||
})
|
||
};
|
||
jQuery.fn.extend({
|
||
wrapAll: function (html) {
|
||
var wrap;
|
||
if (jQuery.isFunction(html)) {
|
||
return this.each(function (i) {
|
||
jQuery(this).wrapAll(html.call(this, i))
|
||
})
|
||
}
|
||
if (this[0]) {
|
||
// The elements to wrap the target around
|
||
wrap = jQuery(html, this[0].ownerDocument).eq(0).clone(true);
|
||
if (this[0].parentNode) {
|
||
wrap.insertBefore(this[0])
|
||
}
|
||
wrap.map(function () {
|
||
var elem = this;
|
||
while (elem.firstElementChild) {
|
||
elem = elem.firstElementChild
|
||
}
|
||
return elem
|
||
}).append(this)
|
||
}
|
||
return this
|
||
},
|
||
wrapInner: function (html) {
|
||
if (jQuery.isFunction(html)) {
|
||
return this.each(function (i) {
|
||
jQuery(this).wrapInner(html.call(this, i))
|
||
})
|
||
}
|
||
return this.each(function () {
|
||
var self = jQuery(this), contents = self.contents();
|
||
if (contents.length) {
|
||
contents.wrapAll(html)
|
||
} else {
|
||
self.append(html)
|
||
}
|
||
})
|
||
},
|
||
wrap: function (html) {
|
||
var isFunction = jQuery.isFunction(html);
|
||
return this.each(function (i) {
|
||
jQuery(this).wrapAll(isFunction ? html.call(this, i) : html)
|
||
})
|
||
},
|
||
unwrap: function () {
|
||
return this.parent().each(function () {
|
||
if (!jQuery.nodeName(this, 'body')) {
|
||
jQuery(this).replaceWith(this.childNodes)
|
||
}
|
||
}).end()
|
||
}
|
||
});
|
||
jQuery.expr.filters.hidden = function (elem) {
|
||
return !jQuery.expr.filters.visible(elem)
|
||
};
|
||
jQuery.expr.filters.visible = function (elem) {
|
||
// Support: Opera <= 12.12
|
||
// Opera reports offsetWidths and offsetHeights less than zero on some elements
|
||
// Use OR instead of AND as the element is not visible if either is true
|
||
// See tickets #10406 and #13132
|
||
return elem.offsetWidth > 0 || elem.offsetHeight > 0 || elem.getClientRects().length > 0
|
||
};
|
||
var r20 = /%20/g, rbracket = /\[\]$/, rCRLF = /\r?\n/g, rsubmitterTypes = /^(?:submit|button|image|reset|file)$/i, rsubmittable = /^(?:input|select|textarea|keygen)/i;
|
||
function buildParams(prefix, obj, traditional, add) {
|
||
var name;
|
||
if (jQuery.isArray(obj)) {
|
||
// Serialize array item.
|
||
jQuery.each(obj, function (i, v) {
|
||
if (traditional || rbracket.test(prefix)) {
|
||
// Treat each array item as a scalar.
|
||
add(prefix, v)
|
||
} else {
|
||
// Item is non-scalar (array or object), encode its numeric index.
|
||
buildParams(prefix + '[' + (typeof v === 'object' && v != null ? i : '') + ']', v, traditional, add)
|
||
}
|
||
})
|
||
} else if (!traditional && jQuery.type(obj) === 'object') {
|
||
// Serialize object item.
|
||
for (name in obj) {
|
||
buildParams(prefix + '[' + name + ']', obj[name], traditional, add)
|
||
}
|
||
} else {
|
||
// Serialize scalar item.
|
||
add(prefix, obj)
|
||
}
|
||
}
|
||
// Serialize an array of form elements or a set of
|
||
// key/values into a query string
|
||
jQuery.param = function (a, traditional) {
|
||
var prefix, s = [], add = function (key, value) {
|
||
// If value is a function, invoke it and return its value
|
||
value = jQuery.isFunction(value) ? value() : value == null ? '' : value;
|
||
s[s.length] = encodeURIComponent(key) + '=' + encodeURIComponent(value)
|
||
};
|
||
// Set traditional to true for jQuery <= 1.3.2 behavior.
|
||
if (traditional === undefined) {
|
||
traditional = jQuery.ajaxSettings && jQuery.ajaxSettings.traditional
|
||
}
|
||
// If an array was passed in, assume that it is an array of form elements.
|
||
if (jQuery.isArray(a) || a.jquery && !jQuery.isPlainObject(a)) {
|
||
// Serialize the form elements
|
||
jQuery.each(a, function () {
|
||
add(this.name, this.value)
|
||
})
|
||
} else {
|
||
// If traditional, encode the "old" way (the way 1.3.2 or older
|
||
// did it), otherwise encode params recursively.
|
||
for (prefix in a) {
|
||
buildParams(prefix, a[prefix], traditional, add)
|
||
}
|
||
}
|
||
// Return the resulting serialization
|
||
return s.join('&').replace(r20, '+')
|
||
};
|
||
jQuery.fn.extend({
|
||
serialize: function () {
|
||
return jQuery.param(this.serializeArray())
|
||
},
|
||
serializeArray: function () {
|
||
return this.map(function () {
|
||
// Can add propHook for "elements" to filter or add form elements
|
||
var elements = jQuery.prop(this, 'elements');
|
||
return elements ? jQuery.makeArray(elements) : this
|
||
}).filter(function () {
|
||
var type = this.type;
|
||
// Use .is( ":disabled" ) so that fieldset[disabled] works
|
||
return this.name && !jQuery(this).is(':disabled') && rsubmittable.test(this.nodeName) && !rsubmitterTypes.test(type) && (this.checked || !rcheckableType.test(type))
|
||
}).map(function (i, elem) {
|
||
var val = jQuery(this).val();
|
||
return val == null ? null : jQuery.isArray(val) ? jQuery.map(val, function (val) {
|
||
return {
|
||
name: elem.name,
|
||
value: val.replace(rCRLF, '\r\n')
|
||
}
|
||
}) : {
|
||
name: elem.name,
|
||
value: val.replace(rCRLF, '\r\n')
|
||
}
|
||
}).get()
|
||
}
|
||
});
|
||
jQuery.ajaxSettings.xhr = function () {
|
||
try {
|
||
return new window.XMLHttpRequest
|
||
} catch (e) {
|
||
}
|
||
};
|
||
var xhrSuccessStatus = {
|
||
// File protocol always yields status code 0, assume 200
|
||
0: 200,
|
||
// Support: IE9
|
||
// #1450: sometimes IE returns 1223 when it should be 204
|
||
1223: 204
|
||
}, xhrSupported = jQuery.ajaxSettings.xhr();
|
||
support.cors = !!xhrSupported && 'withCredentials' in xhrSupported;
|
||
support.ajax = xhrSupported = !!xhrSupported;
|
||
jQuery.ajaxTransport(function (options) {
|
||
var callback, errorCallback;
|
||
// Cross domain only allowed if supported through XMLHttpRequest
|
||
if (support.cors || xhrSupported && !options.crossDomain) {
|
||
return {
|
||
send: function (headers, complete) {
|
||
var i, xhr = options.xhr();
|
||
xhr.open(options.type, options.url, options.async, options.username, options.password);
|
||
// Apply custom fields if provided
|
||
if (options.xhrFields) {
|
||
for (i in options.xhrFields) {
|
||
xhr[i] = options.xhrFields[i]
|
||
}
|
||
}
|
||
// Override mime type if needed
|
||
if (options.mimeType && xhr.overrideMimeType) {
|
||
xhr.overrideMimeType(options.mimeType)
|
||
}
|
||
// X-Requested-With header
|
||
// For cross-domain requests, seeing as conditions for a preflight are
|
||
// akin to a jigsaw puzzle, we simply never set it to be sure.
|
||
// (it can always be set on a per-request basis or even using ajaxSetup)
|
||
// For same-domain requests, won't change header if already provided.
|
||
if (!options.crossDomain && !headers['X-Requested-With']) {
|
||
headers['X-Requested-With'] = 'XMLHttpRequest'
|
||
}
|
||
// Set headers
|
||
for (i in headers) {
|
||
xhr.setRequestHeader(i, headers[i])
|
||
}
|
||
// Callback
|
||
callback = function (type) {
|
||
return function () {
|
||
if (callback) {
|
||
callback = errorCallback = xhr.onload = xhr.onerror = xhr.onabort = xhr.onreadystatechange = null;
|
||
if (type === 'abort') {
|
||
xhr.abort()
|
||
} else if (type === 'error') {
|
||
// Support: IE9
|
||
// On a manual native abort, IE9 throws
|
||
// errors on any property access that is not readyState
|
||
if (typeof xhr.status !== 'number') {
|
||
complete(0, 'error')
|
||
} else {
|
||
complete(// File: protocol always yields status 0; see #8605, #14207
|
||
xhr.status, xhr.statusText)
|
||
}
|
||
} else {
|
||
complete(xhrSuccessStatus[xhr.status] || xhr.status, xhr.statusText, // Support: IE9 only
|
||
// IE9 has no XHR2 but throws on binary (trac-11426)
|
||
// For XHR2 non-text, let the caller handle it (gh-2498)
|
||
(xhr.responseType || 'text') !== 'text' || typeof xhr.responseText !== 'string' ? { binary: xhr.response } : { text: xhr.responseText }, xhr.getAllResponseHeaders())
|
||
}
|
||
}
|
||
}
|
||
};
|
||
// Listen to events
|
||
xhr.onload = callback();
|
||
errorCallback = xhr.onerror = callback('error');
|
||
// Support: IE9
|
||
// Use onreadystatechange to replace onabort
|
||
// to handle uncaught aborts
|
||
if (xhr.onabort !== undefined) {
|
||
xhr.onabort = errorCallback
|
||
} else {
|
||
xhr.onreadystatechange = function () {
|
||
// Check readyState before timeout as it changes
|
||
if (xhr.readyState === 4) {
|
||
// Allow onerror to be called first,
|
||
// but that will not handle a native abort
|
||
// Also, save errorCallback to a variable
|
||
// as xhr.onerror cannot be accessed
|
||
window.setTimeout(function () {
|
||
if (callback) {
|
||
errorCallback()
|
||
}
|
||
})
|
||
}
|
||
}
|
||
}
|
||
// Create the abort callback
|
||
callback = callback('abort');
|
||
try {
|
||
// Do send the request (this may raise an exception)
|
||
xhr.send(options.hasContent && options.data || null)
|
||
} catch (e) {
|
||
// #14683: Only rethrow if this hasn't been notified as an error yet
|
||
if (callback) {
|
||
throw e
|
||
}
|
||
}
|
||
},
|
||
abort: function () {
|
||
if (callback) {
|
||
callback()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
// Install script dataType
|
||
jQuery.ajaxSetup({
|
||
accepts: { script: 'text/javascript, application/javascript, ' + 'application/ecmascript, application/x-ecmascript' },
|
||
contents: { script: /\b(?:java|ecma)script\b/ },
|
||
converters: {
|
||
'text script': function (text) {
|
||
jQuery.globalEval(text);
|
||
return text
|
||
}
|
||
}
|
||
});
|
||
// Handle cache's special case and crossDomain
|
||
jQuery.ajaxPrefilter('script', function (s) {
|
||
if (s.cache === undefined) {
|
||
s.cache = false
|
||
}
|
||
if (s.crossDomain) {
|
||
s.type = 'GET'
|
||
}
|
||
});
|
||
// Bind script tag hack transport
|
||
jQuery.ajaxTransport('script', function (s) {
|
||
// This transport only deals with cross domain requests
|
||
if (s.crossDomain) {
|
||
var script, callback;
|
||
return {
|
||
send: function (_, complete) {
|
||
script = jQuery('<script>').prop({
|
||
charset: s.scriptCharset,
|
||
src: s.url
|
||
}).on('load error', callback = function (evt) {
|
||
script.remove();
|
||
callback = null;
|
||
if (evt) {
|
||
complete(evt.type === 'error' ? 404 : 200, evt.type)
|
||
}
|
||
});
|
||
// Use native DOM manipulation to avoid our domManip AJAX trickery
|
||
document.head.appendChild(script[0])
|
||
},
|
||
abort: function () {
|
||
if (callback) {
|
||
callback()
|
||
}
|
||
}
|
||
}
|
||
}
|
||
});
|
||
var oldCallbacks = [], rjsonp = /(=)\?(?=&|$)|\?\?/;
|
||
// Default jsonp settings
|
||
jQuery.ajaxSetup({
|
||
jsonp: 'callback',
|
||
jsonpCallback: function () {
|
||
var callback = oldCallbacks.pop() || jQuery.expando + '_' + nonce++;
|
||
this[callback] = true;
|
||
return callback
|
||
}
|
||
});
|
||
// Detect, normalize options and install callbacks for jsonp requests
|
||
jQuery.ajaxPrefilter('json jsonp', function (s, originalSettings, jqXHR) {
|
||
var callbackName, overwritten, responseContainer, jsonProp = s.jsonp !== false && (rjsonp.test(s.url) ? 'url' : typeof s.data === 'string' && (s.contentType || '').indexOf('application/x-www-form-urlencoded') === 0 && rjsonp.test(s.data) && 'data');
|
||
// Handle iff the expected data type is "jsonp" or we have a parameter to set
|
||
if (jsonProp || s.dataTypes[0] === 'jsonp') {
|
||
// Get callback name, remembering preexisting value associated with it
|
||
callbackName = s.jsonpCallback = jQuery.isFunction(s.jsonpCallback) ? s.jsonpCallback() : s.jsonpCallback;
|
||
// Insert callback into url or form data
|
||
if (jsonProp) {
|
||
s[jsonProp] = s[jsonProp].replace(rjsonp, '$1' + callbackName)
|
||
} else if (s.jsonp !== false) {
|
||
s.url += (rquery.test(s.url) ? '&' : '?') + s.jsonp + '=' + callbackName
|
||
}
|
||
// Use data converter to retrieve json after script execution
|
||
s.converters['script json'] = function () {
|
||
if (!responseContainer) {
|
||
jQuery.error(callbackName + ' was not called')
|
||
}
|
||
return responseContainer[0]
|
||
};
|
||
// Force json dataType
|
||
s.dataTypes[0] = 'json';
|
||
// Install callback
|
||
overwritten = window[callbackName];
|
||
window[callbackName] = function () {
|
||
responseContainer = arguments
|
||
};
|
||
// Clean-up function (fires after converters)
|
||
jqXHR.always(function () {
|
||
// If previous value didn't exist - remove it
|
||
if (overwritten === undefined) {
|
||
jQuery(window).removeProp(callbackName) // Otherwise restore preexisting value
|
||
} else {
|
||
window[callbackName] = overwritten
|
||
}
|
||
// Save back as free
|
||
if (s[callbackName]) {
|
||
// Make sure that re-using the options doesn't screw things around
|
||
s.jsonpCallback = originalSettings.jsonpCallback;
|
||
// Save the callback name for future use
|
||
oldCallbacks.push(callbackName)
|
||
}
|
||
// Call if it was a function and we have a response
|
||
if (responseContainer && jQuery.isFunction(overwritten)) {
|
||
overwritten(responseContainer[0])
|
||
}
|
||
responseContainer = overwritten = undefined
|
||
});
|
||
// Delegate to script
|
||
return 'script'
|
||
}
|
||
});
|
||
// Argument "data" should be string of html
|
||
// context (optional): If specified, the fragment will be created in this context,
|
||
// defaults to document
|
||
// keepScripts (optional): If true, will include scripts passed in the html string
|
||
jQuery.parseHTML = function (data, context, keepScripts) {
|
||
if (!data || typeof data !== 'string') {
|
||
return null
|
||
}
|
||
if (typeof context === 'boolean') {
|
||
keepScripts = context;
|
||
context = false
|
||
}
|
||
context = context || document;
|
||
var parsed = rsingleTag.exec(data), scripts = !keepScripts && [];
|
||
// Single tag
|
||
if (parsed) {
|
||
return [context.createElement(parsed[1])]
|
||
}
|
||
parsed = buildFragment([data], context, scripts);
|
||
if (scripts && scripts.length) {
|
||
jQuery(scripts).remove()
|
||
}
|
||
return jQuery.merge([], parsed.childNodes)
|
||
};
|
||
// Keep a copy of the old load method
|
||
var _load = jQuery.fn.load;
|
||
/**
|
||
* Load a url into a page
|
||
*/
|
||
jQuery.fn.load = function (url, params, callback) {
|
||
if (typeof url !== 'string' && _load) {
|
||
return _load.apply(this, arguments)
|
||
}
|
||
var selector, type, response, self = this, off = url.indexOf(' ');
|
||
if (off > -1) {
|
||
selector = jQuery.trim(url.slice(off));
|
||
url = url.slice(0, off)
|
||
}
|
||
// If it's a function
|
||
if (jQuery.isFunction(params)) {
|
||
// We assume that it's the callback
|
||
callback = params;
|
||
params = undefined // Otherwise, build a param string
|
||
} else if (params && typeof params === 'object') {
|
||
type = 'POST'
|
||
}
|
||
// If we have elements to modify, make the request
|
||
if (self.length > 0) {
|
||
jQuery.ajax({
|
||
url: url,
|
||
// If "type" variable is undefined, then "GET" method will be used.
|
||
// Make value of this field explicit since
|
||
// user can override it through ajaxSetup method
|
||
type: type || 'GET',
|
||
dataType: 'html',
|
||
data: params
|
||
}).done(function (responseText) {
|
||
// Save response for use in complete callback
|
||
response = arguments;
|
||
self.html(selector ? // If a selector was specified, locate the right elements in a dummy div
|
||
// Exclude scripts to avoid IE 'Permission Denied' errors
|
||
jQuery('<div>').append(jQuery.parseHTML(responseText)).find(selector) : // Otherwise use the full result
|
||
responseText) // If the request succeeds, this function gets "data", "status", "jqXHR"
|
||
// but they are ignored because response was set above.
|
||
// If it fails, this function gets "jqXHR", "status", "error"
|
||
}).always(callback && function (jqXHR, status) {
|
||
self.each(function () {
|
||
callback.apply(self, response || [
|
||
jqXHR.responseText,
|
||
status,
|
||
jqXHR
|
||
])
|
||
})
|
||
})
|
||
}
|
||
return this
|
||
};
|
||
// Attach a bunch of functions for handling common AJAX events
|
||
jQuery.each([
|
||
'ajaxStart',
|
||
'ajaxStop',
|
||
'ajaxComplete',
|
||
'ajaxError',
|
||
'ajaxSuccess',
|
||
'ajaxSend'
|
||
], function (i, type) {
|
||
jQuery.fn[type] = function (fn) {
|
||
return this.on(type, fn)
|
||
}
|
||
});
|
||
jQuery.expr.filters.animated = function (elem) {
|
||
return jQuery.grep(jQuery.timers, function (fn) {
|
||
return elem === fn.elem
|
||
}).length
|
||
};
|
||
/**
|
||
* Gets a window from an element
|
||
*/
|
||
function getWindow(elem) {
|
||
return jQuery.isWindow(elem) ? elem : elem.nodeType === 9 && elem.defaultView
|
||
}
|
||
jQuery.offset = {
|
||
setOffset: function (elem, options, i) {
|
||
var curPosition, curLeft, curCSSTop, curTop, curOffset, curCSSLeft, calculatePosition, position = jQuery.css(elem, 'position'), curElem = jQuery(elem), props = {};
|
||
// Set position first, in-case top/left are set even on static elem
|
||
if (position === 'static') {
|
||
elem.style.position = 'relative'
|
||
}
|
||
curOffset = curElem.offset();
|
||
curCSSTop = jQuery.css(elem, 'top');
|
||
curCSSLeft = jQuery.css(elem, 'left');
|
||
calculatePosition = (position === 'absolute' || position === 'fixed') && (curCSSTop + curCSSLeft).indexOf('auto') > -1;
|
||
// Need to be able to calculate position if either
|
||
// top or left is auto and position is either absolute or fixed
|
||
if (calculatePosition) {
|
||
curPosition = curElem.position();
|
||
curTop = curPosition.top;
|
||
curLeft = curPosition.left
|
||
} else {
|
||
curTop = parseFloat(curCSSTop) || 0;
|
||
curLeft = parseFloat(curCSSLeft) || 0
|
||
}
|
||
if (jQuery.isFunction(options)) {
|
||
// Use jQuery.extend here to allow modification of coordinates argument (gh-1848)
|
||
options = options.call(elem, i, jQuery.extend({}, curOffset))
|
||
}
|
||
if (options.top != null) {
|
||
props.top = options.top - curOffset.top + curTop
|
||
}
|
||
if (options.left != null) {
|
||
props.left = options.left - curOffset.left + curLeft
|
||
}
|
||
if ('using' in options) {
|
||
options.using.call(elem, props)
|
||
} else {
|
||
curElem.css(props)
|
||
}
|
||
}
|
||
};
|
||
jQuery.fn.extend({
|
||
offset: function (options) {
|
||
if (arguments.length) {
|
||
return options === undefined ? this : this.each(function (i) {
|
||
jQuery.offset.setOffset(this, options, i)
|
||
})
|
||
}
|
||
var docElem, win, elem = this[0], box = {
|
||
top: 0,
|
||
left: 0
|
||
}, doc = elem && elem.ownerDocument;
|
||
if (!doc) {
|
||
return
|
||
}
|
||
docElem = doc.documentElement;
|
||
// Make sure it's not a disconnected DOM node
|
||
if (!jQuery.contains(docElem, elem)) {
|
||
return box
|
||
}
|
||
box = elem.getBoundingClientRect();
|
||
win = getWindow(doc);
|
||
return {
|
||
top: box.top + win.pageYOffset - docElem.clientTop,
|
||
left: box.left + win.pageXOffset - docElem.clientLeft
|
||
}
|
||
},
|
||
position: function () {
|
||
if (!this[0]) {
|
||
return
|
||
}
|
||
var offsetParent, offset, elem = this[0], parentOffset = {
|
||
top: 0,
|
||
left: 0
|
||
};
|
||
// Fixed elements are offset from window (parentOffset = {top:0, left: 0},
|
||
// because it is its only offset parent
|
||
if (jQuery.css(elem, 'position') === 'fixed') {
|
||
// Assume getBoundingClientRect is there when computed position is fixed
|
||
offset = elem.getBoundingClientRect()
|
||
} else {
|
||
// Get *real* offsetParent
|
||
offsetParent = this.offsetParent();
|
||
// Get correct offsets
|
||
offset = this.offset();
|
||
if (!jQuery.nodeName(offsetParent[0], 'html')) {
|
||
parentOffset = offsetParent.offset()
|
||
}
|
||
// Add offsetParent borders
|
||
parentOffset.top += jQuery.css(offsetParent[0], 'borderTopWidth', true);
|
||
parentOffset.left += jQuery.css(offsetParent[0], 'borderLeftWidth', true)
|
||
}
|
||
// Subtract parent offsets and element margins
|
||
return {
|
||
top: offset.top - parentOffset.top - jQuery.css(elem, 'marginTop', true),
|
||
left: offset.left - parentOffset.left - jQuery.css(elem, 'marginLeft', true)
|
||
}
|
||
},
|
||
// This method will return documentElement in the following cases:
|
||
// 1) For the element inside the iframe without offsetParent, this method will return
|
||
// documentElement of the parent window
|
||
// 2) For the hidden or detached element
|
||
// 3) For body or html element, i.e. in case of the html node - it will return itself
|
||
//
|
||
// but those exceptions were never presented as a real life use-cases
|
||
// and might be considered as more preferable results.
|
||
//
|
||
// This logic, however, is not guaranteed and can change at any point in the future
|
||
offsetParent: function () {
|
||
return this.map(function () {
|
||
var offsetParent = this.offsetParent;
|
||
while (offsetParent && jQuery.css(offsetParent, 'position') === 'static') {
|
||
offsetParent = offsetParent.offsetParent
|
||
}
|
||
return offsetParent || documentElement
|
||
})
|
||
}
|
||
});
|
||
// Create scrollLeft and scrollTop methods
|
||
jQuery.each({
|
||
scrollLeft: 'pageXOffset',
|
||
scrollTop: 'pageYOffset'
|
||
}, function (method, prop) {
|
||
var top = 'pageYOffset' === prop;
|
||
jQuery.fn[method] = function (val) {
|
||
return access(this, function (elem, method, val) {
|
||
var win = getWindow(elem);
|
||
if (val === undefined) {
|
||
return win ? win[prop] : elem[method]
|
||
}
|
||
if (win) {
|
||
win.scrollTo(!top ? val : win.pageXOffset, top ? val : win.pageYOffset)
|
||
} else {
|
||
elem[method] = val
|
||
}
|
||
}, method, val, arguments.length)
|
||
}
|
||
});
|
||
// Support: Safari<7-8+, Chrome<37-44+
|
||
// Add the top/left cssHooks using jQuery.fn.position
|
||
// Webkit bug: https://bugs.webkit.org/show_bug.cgi?id=29084
|
||
// Blink bug: https://code.google.com/p/chromium/issues/detail?id=229280
|
||
// getComputedStyle returns percent when specified for top/left/bottom/right;
|
||
// rather than make the css module depend on the offset module, just check for it here
|
||
jQuery.each([
|
||
'top',
|
||
'left'
|
||
], function (i, prop) {
|
||
jQuery.cssHooks[prop] = addGetHookIf(support.pixelPosition, function (elem, computed) {
|
||
if (computed) {
|
||
computed = curCSS(elem, prop);
|
||
// If curCSS returns percentage, fallback to offset
|
||
return rnumnonpx.test(computed) ? jQuery(elem).position()[prop] + 'px' : computed
|
||
}
|
||
})
|
||
});
|
||
// Create innerHeight, innerWidth, height, width, outerHeight and outerWidth methods
|
||
jQuery.each({
|
||
Height: 'height',
|
||
Width: 'width'
|
||
}, function (name, type) {
|
||
jQuery.each({
|
||
padding: 'inner' + name,
|
||
content: type,
|
||
'': 'outer' + name
|
||
}, function (defaultExtra, funcName) {
|
||
// Margin is only for outerHeight, outerWidth
|
||
jQuery.fn[funcName] = function (margin, value) {
|
||
var chainable = arguments.length && (defaultExtra || typeof margin !== 'boolean'), extra = defaultExtra || (margin === true || value === true ? 'margin' : 'border');
|
||
return access(this, function (elem, type, value) {
|
||
var doc;
|
||
if (jQuery.isWindow(elem)) {
|
||
// As of 5/8/2012 this will yield incorrect results for Mobile Safari, but there
|
||
// isn't a whole lot we can do. See pull request at this URL for discussion:
|
||
// https://github.com/jquery/jquery/pull/764
|
||
return elem.document.documentElement['client' + name]
|
||
}
|
||
// Get document width or height
|
||
if (elem.nodeType === 9) {
|
||
doc = elem.documentElement;
|
||
// Either scroll[Width/Height] or offset[Width/Height] or client[Width/Height],
|
||
// whichever is greatest
|
||
return Math.max(elem.body['scroll' + name], doc['scroll' + name], elem.body['offset' + name], doc['offset' + name], doc['client' + name])
|
||
}
|
||
return value === undefined ? // Get width or height on the element, requesting but not forcing parseFloat
|
||
jQuery.css(elem, type, extra) : // Set width or height on the element
|
||
jQuery.style(elem, type, value, extra)
|
||
}, type, chainable ? margin : undefined, chainable, null)
|
||
}
|
||
})
|
||
});
|
||
jQuery.fn.extend({
|
||
bind: function (types, data, fn) {
|
||
return this.on(types, null, data, fn)
|
||
},
|
||
unbind: function (types, fn) {
|
||
return this.off(types, null, fn)
|
||
},
|
||
delegate: function (selector, types, data, fn) {
|
||
return this.on(types, selector, data, fn)
|
||
},
|
||
undelegate: function (selector, types, fn) {
|
||
// ( namespace ) or ( selector, types [, fn] )
|
||
return arguments.length === 1 ? this.off(selector, '**') : this.off(types, selector || '**', fn)
|
||
},
|
||
size: function () {
|
||
return this.length
|
||
}
|
||
});
|
||
jQuery.fn.andSelf = jQuery.fn.addBack;
|
||
// Register as a named AMD module, since jQuery can be concatenated with other
|
||
// files that may use define, but not via a proper concatenation script that
|
||
// understands anonymous AMD modules. A named AMD is safest and most robust
|
||
// way to register. Lowercase jquery is used because AMD module names are
|
||
// derived from file names, and jQuery is normally delivered in a lowercase
|
||
// file name. Do this after creating the global so that if an AMD module wants
|
||
// to call noConflict to hide this version of jQuery, it will work.
|
||
// Note that for maximum portability, libraries that are not jQuery should
|
||
// declare themselves as anonymous modules, and avoid setting a global if an
|
||
// AMD loader is present. jQuery is a special case. For more information, see
|
||
// https://github.com/jrburke/requirejs/wiki/Updating-existing-libraries#wiki-anon
|
||
if (typeof define === 'function' && define.amd) {
|
||
define('jquery', [], function () {
|
||
return jQuery
|
||
})
|
||
}
|
||
var
|
||
// Map over jQuery in case of overwrite
|
||
_jQuery = window.jQuery,
|
||
// Map over the $ in case of overwrite
|
||
_$ = window.$;
|
||
jQuery.noConflict = function (deep) {
|
||
if (window.$ === jQuery) {
|
||
window.$ = _$
|
||
}
|
||
if (deep && window.jQuery === jQuery) {
|
||
window.jQuery = _jQuery
|
||
}
|
||
return jQuery
|
||
};
|
||
// Expose jQuery and $ identifiers, even in AMD
|
||
// (#7102#comment:10, https://github.com/jquery/jquery/pull/557)
|
||
// and CommonJS for browser emulators (#13566)
|
||
if (!noGlobal) {
|
||
window.jQuery = window.$ = jQuery
|
||
}
|
||
return jQuery
|
||
}))
|
||
});
|
||
// source: src/controls/text.coffee
|
||
require.define('./controls/text', function (module, exports, __dirname, __filename, process) {
|
||
var Control, Text, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
Control = require('./controls/control');
|
||
module.exports = Text = function (superClass) {
|
||
extend(Text, superClass);
|
||
function Text() {
|
||
return Text.__super__.constructor.apply(this, arguments)
|
||
}
|
||
Text.prototype.tag = 'daisho-text-control';
|
||
Text.prototype.type = 'text';
|
||
Text.prototype.html = require('./Users/dtai/work/hanzo/daisho-riot/templates/text');
|
||
Text.prototype.realtime = false;
|
||
Text.prototype.init = function () {
|
||
return Text.__super__.init.apply(this, arguments)
|
||
};
|
||
Text.prototype.keyup = function () {
|
||
if (this.realtime) {
|
||
this.change.apply(this, arguments)
|
||
}
|
||
return true
|
||
};
|
||
return Text
|
||
}(Control)
|
||
});
|
||
// source: templates/text.html
|
||
require.define('./Users/dtai/work/hanzo/daisho-riot/templates/text', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = '<input id="{ input.name }" name="{ name || input.name }" type="{ type }" class="{ filled: input.ref(input.name) }" onchange="{ change }" onblur="{ change }" onkeyup="{ keyup }" value="{ input.ref(input.name) }">\n<label for="{ input.name }">{ placeholder }</label>\n'
|
||
});
|
||
// source: src/controls/inline-text.coffee
|
||
require.define('./controls/inline-text', function (module, exports, __dirname, __filename, process) {
|
||
var InlineText, Text, placeholder, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
Text = require('./controls/text');
|
||
placeholder = require('./utils/placeholder');
|
||
module.exports = InlineText = function (superClass) {
|
||
extend(InlineText, superClass);
|
||
function InlineText() {
|
||
return InlineText.__super__.constructor.apply(this, arguments)
|
||
}
|
||
InlineText.prototype.tag = 'daisho-inline-text-control';
|
||
InlineText.prototype.html = require('./Users/dtai/work/hanzo/daisho-riot/templates/inline-text');
|
||
InlineText.prototype.type = 'text';
|
||
InlineText.prototype.label = '';
|
||
InlineText.prototype.init = function () {
|
||
InlineText.__super__.init.apply(this, arguments);
|
||
return this.on('updated', function (_this) {
|
||
return function () {
|
||
var el;
|
||
el = _this.root.getElementsByTagName(_this.formElement)[0];
|
||
if (_this.type !== 'password') {
|
||
return placeholder(el)
|
||
}
|
||
}
|
||
}(this))
|
||
};
|
||
return InlineText
|
||
}(Text)
|
||
});
|
||
// source: src/utils/placeholder.coffee
|
||
require.define('./utils/placeholder', function (module, exports, __dirname, __filename, process) {
|
||
var hidePlaceholderOnFocus, unfocusOnAnElement;
|
||
hidePlaceholderOnFocus = function (event) {
|
||
var target;
|
||
target = event.currentTarget ? event.currentTarget : event.srcElement;
|
||
if (target.value === target.getAttribute('placeholder')) {
|
||
return target.value = ''
|
||
}
|
||
};
|
||
unfocusOnAnElement = function (event) {
|
||
var target;
|
||
target = event.currentTarget ? event.currentTarget : event.srcElement;
|
||
if (target.value === '') {
|
||
return target.value = target.getAttribute('placeholder')
|
||
}
|
||
};
|
||
if (document.createElement('input').placeholder != null) {
|
||
module.exports = function () {
|
||
}
|
||
} else {
|
||
module.exports = function (input) {
|
||
var ref;
|
||
input = (ref = input[0]) != null ? ref : input;
|
||
if (input._placeholdered != null) {
|
||
return
|
||
}
|
||
Object.defineProperty(input, '_placeholdered', {
|
||
value: true,
|
||
writable: true
|
||
});
|
||
if (!input.value) {
|
||
input.value = input.getAttribute('placeholder')
|
||
}
|
||
if (input.addEventListener) {
|
||
input.addEventListener('click', hidePlaceholderOnFocus, false);
|
||
return input.addEventListener('blur', unfocusOnAnElement, false)
|
||
} else if (input.attachEvent) {
|
||
input.attachEvent('onclick', hidePlaceholderOnFocus);
|
||
return input.attachEvent('onblur', unfocusOnAnElement)
|
||
}
|
||
}
|
||
}
|
||
});
|
||
// source: templates/inline-text.html
|
||
require.define('./Users/dtai/work/hanzo/daisho-riot/templates/inline-text', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = '<input id="{ input.name }" name="{ name || input.name }" type="{ type }" class="{ filled: input.ref(input.name) }" onchange="{ change }" onblur="{ change }" onkeyup="{ keyup }" value="{ input.ref(input.name) }" placeholder="{ placeholder }">\n<label for="{ input.name }" if="{ label }">{ label }</label>\n\n'
|
||
});
|
||
// source: src/controls/static-text.coffee
|
||
require.define('./controls/static-text', function (module, exports, __dirname, __filename, process) {
|
||
var Control, StaticText, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
Control = require('./controls/control');
|
||
module.exports = StaticText = function (superClass) {
|
||
extend(StaticText, superClass);
|
||
function StaticText() {
|
||
return StaticText.__super__.constructor.apply(this, arguments)
|
||
}
|
||
StaticText.prototype.tag = 'daisho-static-text';
|
||
StaticText.prototype.html = '<div>{ input.ref.get(input.name) }</div>';
|
||
StaticText.prototype.init = function () {
|
||
return StaticText.__super__.init.apply(this, arguments)
|
||
};
|
||
return StaticText
|
||
}(Control)
|
||
});
|
||
// source: src/controls/static-date.coffee
|
||
require.define('./controls/static-date', function (module, exports, __dirname, __filename, process) {
|
||
var Control, StaticDate, moment, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
Control = require('./controls/control');
|
||
moment = require('moment/moment');
|
||
module.exports = StaticDate = function (superClass) {
|
||
extend(StaticDate, superClass);
|
||
function StaticDate() {
|
||
return StaticDate.__super__.constructor.apply(this, arguments)
|
||
}
|
||
StaticDate.prototype.tag = 'daisho-static-date';
|
||
StaticDate.prototype.html = '<div>{ format(input.ref.get(input.name)) }</div>';
|
||
StaticDate.prototype.init = function () {
|
||
return StaticDate.__super__.init.apply(this, arguments)
|
||
};
|
||
StaticDate.prototype.format = function (date) {
|
||
return moment(date).format('LLL')
|
||
};
|
||
return StaticDate
|
||
}(Control)
|
||
});
|
||
// source: node_modules/moment/moment.js
|
||
require.define('moment/moment', function (module, exports, __dirname, __filename, process) {
|
||
//! moment.js
|
||
//! version : 2.12.0
|
||
//! authors : Tim Wood, Iskren Chernev, Moment.js contributors
|
||
//! license : MIT
|
||
//! momentjs.com
|
||
;
|
||
(function (global, factory) {
|
||
typeof exports === 'object' && typeof module !== 'undefined' ? module.exports = factory() : typeof define === 'function' && define.amd ? define(factory) : global.moment = factory()
|
||
}(this, function () {
|
||
'use strict';
|
||
var hookCallback;
|
||
function utils_hooks__hooks() {
|
||
return hookCallback.apply(null, arguments)
|
||
}
|
||
// This is done to register the method called with moment()
|
||
// without creating circular dependencies.
|
||
function setHookCallback(callback) {
|
||
hookCallback = callback
|
||
}
|
||
function isArray(input) {
|
||
return input instanceof Array || Object.prototype.toString.call(input) === '[object Array]'
|
||
}
|
||
function isDate(input) {
|
||
return input instanceof Date || Object.prototype.toString.call(input) === '[object Date]'
|
||
}
|
||
function map(arr, fn) {
|
||
var res = [], i;
|
||
for (i = 0; i < arr.length; ++i) {
|
||
res.push(fn(arr[i], i))
|
||
}
|
||
return res
|
||
}
|
||
function hasOwnProp(a, b) {
|
||
return Object.prototype.hasOwnProperty.call(a, b)
|
||
}
|
||
function extend(a, b) {
|
||
for (var i in b) {
|
||
if (hasOwnProp(b, i)) {
|
||
a[i] = b[i]
|
||
}
|
||
}
|
||
if (hasOwnProp(b, 'toString')) {
|
||
a.toString = b.toString
|
||
}
|
||
if (hasOwnProp(b, 'valueOf')) {
|
||
a.valueOf = b.valueOf
|
||
}
|
||
return a
|
||
}
|
||
function create_utc__createUTC(input, format, locale, strict) {
|
||
return createLocalOrUTC(input, format, locale, strict, true).utc()
|
||
}
|
||
function defaultParsingFlags() {
|
||
// We need to deep clone this object.
|
||
return {
|
||
empty: false,
|
||
unusedTokens: [],
|
||
unusedInput: [],
|
||
overflow: -2,
|
||
charsLeftOver: 0,
|
||
nullInput: false,
|
||
invalidMonth: null,
|
||
invalidFormat: false,
|
||
userInvalidated: false,
|
||
iso: false
|
||
}
|
||
}
|
||
function getParsingFlags(m) {
|
||
if (m._pf == null) {
|
||
m._pf = defaultParsingFlags()
|
||
}
|
||
return m._pf
|
||
}
|
||
function valid__isValid(m) {
|
||
if (m._isValid == null) {
|
||
var flags = getParsingFlags(m);
|
||
m._isValid = !isNaN(m._d.getTime()) && flags.overflow < 0 && !flags.empty && !flags.invalidMonth && !flags.invalidWeekday && !flags.nullInput && !flags.invalidFormat && !flags.userInvalidated;
|
||
if (m._strict) {
|
||
m._isValid = m._isValid && flags.charsLeftOver === 0 && flags.unusedTokens.length === 0 && flags.bigHour === undefined
|
||
}
|
||
}
|
||
return m._isValid
|
||
}
|
||
function valid__createInvalid(flags) {
|
||
var m = create_utc__createUTC(NaN);
|
||
if (flags != null) {
|
||
extend(getParsingFlags(m), flags)
|
||
} else {
|
||
getParsingFlags(m).userInvalidated = true
|
||
}
|
||
return m
|
||
}
|
||
function isUndefined(input) {
|
||
return input === void 0
|
||
}
|
||
// Plugins that add properties should also add the key here (null value),
|
||
// so we can properly clone ourselves.
|
||
var momentProperties = utils_hooks__hooks.momentProperties = [];
|
||
function copyConfig(to, from) {
|
||
var i, prop, val;
|
||
if (!isUndefined(from._isAMomentObject)) {
|
||
to._isAMomentObject = from._isAMomentObject
|
||
}
|
||
if (!isUndefined(from._i)) {
|
||
to._i = from._i
|
||
}
|
||
if (!isUndefined(from._f)) {
|
||
to._f = from._f
|
||
}
|
||
if (!isUndefined(from._l)) {
|
||
to._l = from._l
|
||
}
|
||
if (!isUndefined(from._strict)) {
|
||
to._strict = from._strict
|
||
}
|
||
if (!isUndefined(from._tzm)) {
|
||
to._tzm = from._tzm
|
||
}
|
||
if (!isUndefined(from._isUTC)) {
|
||
to._isUTC = from._isUTC
|
||
}
|
||
if (!isUndefined(from._offset)) {
|
||
to._offset = from._offset
|
||
}
|
||
if (!isUndefined(from._pf)) {
|
||
to._pf = getParsingFlags(from)
|
||
}
|
||
if (!isUndefined(from._locale)) {
|
||
to._locale = from._locale
|
||
}
|
||
if (momentProperties.length > 0) {
|
||
for (i in momentProperties) {
|
||
prop = momentProperties[i];
|
||
val = from[prop];
|
||
if (!isUndefined(val)) {
|
||
to[prop] = val
|
||
}
|
||
}
|
||
}
|
||
return to
|
||
}
|
||
var updateInProgress = false;
|
||
// Moment prototype object
|
||
function Moment(config) {
|
||
copyConfig(this, config);
|
||
this._d = new Date(config._d != null ? config._d.getTime() : NaN);
|
||
// Prevent infinite loop in case updateOffset creates new moment
|
||
// objects.
|
||
if (updateInProgress === false) {
|
||
updateInProgress = true;
|
||
utils_hooks__hooks.updateOffset(this);
|
||
updateInProgress = false
|
||
}
|
||
}
|
||
function isMoment(obj) {
|
||
return obj instanceof Moment || obj != null && obj._isAMomentObject != null
|
||
}
|
||
function absFloor(number) {
|
||
if (number < 0) {
|
||
return Math.ceil(number)
|
||
} else {
|
||
return Math.floor(number)
|
||
}
|
||
}
|
||
function toInt(argumentForCoercion) {
|
||
var coercedNumber = +argumentForCoercion, value = 0;
|
||
if (coercedNumber !== 0 && isFinite(coercedNumber)) {
|
||
value = absFloor(coercedNumber)
|
||
}
|
||
return value
|
||
}
|
||
// compare two arrays, return the number of differences
|
||
function compareArrays(array1, array2, dontConvert) {
|
||
var len = Math.min(array1.length, array2.length), lengthDiff = Math.abs(array1.length - array2.length), diffs = 0, i;
|
||
for (i = 0; i < len; i++) {
|
||
if (dontConvert && array1[i] !== array2[i] || !dontConvert && toInt(array1[i]) !== toInt(array2[i])) {
|
||
diffs++
|
||
}
|
||
}
|
||
return diffs + lengthDiff
|
||
}
|
||
function warn(msg) {
|
||
if (utils_hooks__hooks.suppressDeprecationWarnings === false && typeof console !== 'undefined' && console.warn) {
|
||
console.warn('Deprecation warning: ' + msg)
|
||
}
|
||
}
|
||
function deprecate(msg, fn) {
|
||
var firstTime = true;
|
||
return extend(function () {
|
||
if (firstTime) {
|
||
warn(msg + '\nArguments: ' + Array.prototype.slice.call(arguments).join(', ') + '\n' + new Error().stack);
|
||
firstTime = false
|
||
}
|
||
return fn.apply(this, arguments)
|
||
}, fn)
|
||
}
|
||
var deprecations = {};
|
||
function deprecateSimple(name, msg) {
|
||
if (!deprecations[name]) {
|
||
warn(msg);
|
||
deprecations[name] = true
|
||
}
|
||
}
|
||
utils_hooks__hooks.suppressDeprecationWarnings = false;
|
||
function isFunction(input) {
|
||
return input instanceof Function || Object.prototype.toString.call(input) === '[object Function]'
|
||
}
|
||
function isObject(input) {
|
||
return Object.prototype.toString.call(input) === '[object Object]'
|
||
}
|
||
function locale_set__set(config) {
|
||
var prop, i;
|
||
for (i in config) {
|
||
prop = config[i];
|
||
if (isFunction(prop)) {
|
||
this[i] = prop
|
||
} else {
|
||
this['_' + i] = prop
|
||
}
|
||
}
|
||
this._config = config;
|
||
// Lenient ordinal parsing accepts just a number in addition to
|
||
// number + (possibly) stuff coming from _ordinalParseLenient.
|
||
this._ordinalParseLenient = new RegExp(this._ordinalParse.source + '|' + /\d{1,2}/.source)
|
||
}
|
||
function mergeConfigs(parentConfig, childConfig) {
|
||
var res = extend({}, parentConfig), prop;
|
||
for (prop in childConfig) {
|
||
if (hasOwnProp(childConfig, prop)) {
|
||
if (isObject(parentConfig[prop]) && isObject(childConfig[prop])) {
|
||
res[prop] = {};
|
||
extend(res[prop], parentConfig[prop]);
|
||
extend(res[prop], childConfig[prop])
|
||
} else if (childConfig[prop] != null) {
|
||
res[prop] = childConfig[prop]
|
||
} else {
|
||
delete res[prop]
|
||
}
|
||
}
|
||
}
|
||
return res
|
||
}
|
||
function Locale(config) {
|
||
if (config != null) {
|
||
this.set(config)
|
||
}
|
||
}
|
||
// internal storage for locale config files
|
||
var locales = {};
|
||
var globalLocale;
|
||
function normalizeLocale(key) {
|
||
return key ? key.toLowerCase().replace('_', '-') : key
|
||
}
|
||
// pick the locale from the array
|
||
// try ['en-au', 'en-gb'] as 'en-au', 'en-gb', 'en', as in move through the list trying each
|
||
// substring from most specific to least, but move to the next array item if it's a more specific variant than the current root
|
||
function chooseLocale(names) {
|
||
var i = 0, j, next, locale, split;
|
||
while (i < names.length) {
|
||
split = normalizeLocale(names[i]).split('-');
|
||
j = split.length;
|
||
next = normalizeLocale(names[i + 1]);
|
||
next = next ? next.split('-') : null;
|
||
while (j > 0) {
|
||
locale = loadLocale(split.slice(0, j).join('-'));
|
||
if (locale) {
|
||
return locale
|
||
}
|
||
if (next && next.length >= j && compareArrays(split, next, true) >= j - 1) {
|
||
//the next array item is better than a shallower substring of this one
|
||
break
|
||
}
|
||
j--
|
||
}
|
||
i++
|
||
}
|
||
return null
|
||
}
|
||
function loadLocale(name) {
|
||
var oldLocale = null;
|
||
// TODO: Find a better way to register and load all the locales in Node
|
||
if (!locales[name] && typeof module !== 'undefined' && module && module.exports) {
|
||
try {
|
||
oldLocale = globalLocale._abbr;
|
||
require('./locale/' + name);
|
||
// because defineLocale currently also sets the global locale, we
|
||
// want to undo that for lazy loaded locales
|
||
locale_locales__getSetGlobalLocale(oldLocale)
|
||
} catch (e) {
|
||
}
|
||
}
|
||
return locales[name]
|
||
}
|
||
// This function will load locale and then set the global locale. If
|
||
// no arguments are passed in, it will simply return the current global
|
||
// locale key.
|
||
function locale_locales__getSetGlobalLocale(key, values) {
|
||
var data;
|
||
if (key) {
|
||
if (isUndefined(values)) {
|
||
data = locale_locales__getLocale(key)
|
||
} else {
|
||
data = defineLocale(key, values)
|
||
}
|
||
if (data) {
|
||
// moment.duration._locale = moment._locale = data;
|
||
globalLocale = data
|
||
}
|
||
}
|
||
return globalLocale._abbr
|
||
}
|
||
function defineLocale(name, config) {
|
||
if (config !== null) {
|
||
config.abbr = name;
|
||
if (locales[name] != null) {
|
||
deprecateSimple('defineLocaleOverride', 'use moment.updateLocale(localeName, config) to change ' + 'an existing locale. moment.defineLocale(localeName, ' + 'config) should only be used for creating a new locale');
|
||
config = mergeConfigs(locales[name]._config, config)
|
||
} else if (config.parentLocale != null) {
|
||
if (locales[config.parentLocale] != null) {
|
||
config = mergeConfigs(locales[config.parentLocale]._config, config)
|
||
} else {
|
||
// treat as if there is no base config
|
||
deprecateSimple('parentLocaleUndefined', 'specified parentLocale is not defined yet')
|
||
}
|
||
}
|
||
locales[name] = new Locale(config);
|
||
// backwards compat for now: also set the locale
|
||
locale_locales__getSetGlobalLocale(name);
|
||
return locales[name]
|
||
} else {
|
||
// useful for testing
|
||
delete locales[name];
|
||
return null
|
||
}
|
||
}
|
||
function updateLocale(name, config) {
|
||
if (config != null) {
|
||
var locale;
|
||
if (locales[name] != null) {
|
||
config = mergeConfigs(locales[name]._config, config)
|
||
}
|
||
locale = new Locale(config);
|
||
locale.parentLocale = locales[name];
|
||
locales[name] = locale;
|
||
// backwards compat for now: also set the locale
|
||
locale_locales__getSetGlobalLocale(name)
|
||
} else {
|
||
// pass null for config to unupdate, useful for tests
|
||
if (locales[name] != null) {
|
||
if (locales[name].parentLocale != null) {
|
||
locales[name] = locales[name].parentLocale
|
||
} else if (locales[name] != null) {
|
||
delete locales[name]
|
||
}
|
||
}
|
||
}
|
||
return locales[name]
|
||
}
|
||
// returns locale data
|
||
function locale_locales__getLocale(key) {
|
||
var locale;
|
||
if (key && key._locale && key._locale._abbr) {
|
||
key = key._locale._abbr
|
||
}
|
||
if (!key) {
|
||
return globalLocale
|
||
}
|
||
if (!isArray(key)) {
|
||
//short-circuit everything else
|
||
locale = loadLocale(key);
|
||
if (locale) {
|
||
return locale
|
||
}
|
||
key = [key]
|
||
}
|
||
return chooseLocale(key)
|
||
}
|
||
function locale_locales__listLocales() {
|
||
return Object.keys(locales)
|
||
}
|
||
var aliases = {};
|
||
function addUnitAlias(unit, shorthand) {
|
||
var lowerCase = unit.toLowerCase();
|
||
aliases[lowerCase] = aliases[lowerCase + 's'] = aliases[shorthand] = unit
|
||
}
|
||
function normalizeUnits(units) {
|
||
return typeof units === 'string' ? aliases[units] || aliases[units.toLowerCase()] : undefined
|
||
}
|
||
function normalizeObjectUnits(inputObject) {
|
||
var normalizedInput = {}, normalizedProp, prop;
|
||
for (prop in inputObject) {
|
||
if (hasOwnProp(inputObject, prop)) {
|
||
normalizedProp = normalizeUnits(prop);
|
||
if (normalizedProp) {
|
||
normalizedInput[normalizedProp] = inputObject[prop]
|
||
}
|
||
}
|
||
}
|
||
return normalizedInput
|
||
}
|
||
function makeGetSet(unit, keepTime) {
|
||
return function (value) {
|
||
if (value != null) {
|
||
get_set__set(this, unit, value);
|
||
utils_hooks__hooks.updateOffset(this, keepTime);
|
||
return this
|
||
} else {
|
||
return get_set__get(this, unit)
|
||
}
|
||
}
|
||
}
|
||
function get_set__get(mom, unit) {
|
||
return mom.isValid() ? mom._d['get' + (mom._isUTC ? 'UTC' : '') + unit]() : NaN
|
||
}
|
||
function get_set__set(mom, unit, value) {
|
||
if (mom.isValid()) {
|
||
mom._d['set' + (mom._isUTC ? 'UTC' : '') + unit](value)
|
||
}
|
||
}
|
||
// MOMENTS
|
||
function getSet(units, value) {
|
||
var unit;
|
||
if (typeof units === 'object') {
|
||
for (unit in units) {
|
||
this.set(unit, units[unit])
|
||
}
|
||
} else {
|
||
units = normalizeUnits(units);
|
||
if (isFunction(this[units])) {
|
||
return this[units](value)
|
||
}
|
||
}
|
||
return this
|
||
}
|
||
function zeroFill(number, targetLength, forceSign) {
|
||
var absNumber = '' + Math.abs(number), zerosToFill = targetLength - absNumber.length, sign = number >= 0;
|
||
return (sign ? forceSign ? '+' : '' : '-') + Math.pow(10, Math.max(0, zerosToFill)).toString().substr(1) + absNumber
|
||
}
|
||
var formattingTokens = /(\[[^\[]*\])|(\\)?([Hh]mm(ss)?|Mo|MM?M?M?|Do|DDDo|DD?D?D?|ddd?d?|do?|w[o|w]?|W[o|W]?|Qo?|YYYYYY|YYYYY|YYYY|YY|gg(ggg?)?|GG(GGG?)?|e|E|a|A|hh?|HH?|mm?|ss?|S{1,9}|x|X|zz?|ZZ?|.)/g;
|
||
var localFormattingTokens = /(\[[^\[]*\])|(\\)?(LTS|LT|LL?L?L?|l{1,4})/g;
|
||
var formatFunctions = {};
|
||
var formatTokenFunctions = {};
|
||
// token: 'M'
|
||
// padded: ['MM', 2]
|
||
// ordinal: 'Mo'
|
||
// callback: function () { this.month() + 1 }
|
||
function addFormatToken(token, padded, ordinal, callback) {
|
||
var func = callback;
|
||
if (typeof callback === 'string') {
|
||
func = function () {
|
||
return this[callback]()
|
||
}
|
||
}
|
||
if (token) {
|
||
formatTokenFunctions[token] = func
|
||
}
|
||
if (padded) {
|
||
formatTokenFunctions[padded[0]] = function () {
|
||
return zeroFill(func.apply(this, arguments), padded[1], padded[2])
|
||
}
|
||
}
|
||
if (ordinal) {
|
||
formatTokenFunctions[ordinal] = function () {
|
||
return this.localeData().ordinal(func.apply(this, arguments), token)
|
||
}
|
||
}
|
||
}
|
||
function removeFormattingTokens(input) {
|
||
if (input.match(/\[[\s\S]/)) {
|
||
return input.replace(/^\[|\]$/g, '')
|
||
}
|
||
return input.replace(/\\/g, '')
|
||
}
|
||
function makeFormatFunction(format) {
|
||
var array = format.match(formattingTokens), i, length;
|
||
for (i = 0, length = array.length; i < length; i++) {
|
||
if (formatTokenFunctions[array[i]]) {
|
||
array[i] = formatTokenFunctions[array[i]]
|
||
} else {
|
||
array[i] = removeFormattingTokens(array[i])
|
||
}
|
||
}
|
||
return function (mom) {
|
||
var output = '';
|
||
for (i = 0; i < length; i++) {
|
||
output += array[i] instanceof Function ? array[i].call(mom, format) : array[i]
|
||
}
|
||
return output
|
||
}
|
||
}
|
||
// format date using native date object
|
||
function formatMoment(m, format) {
|
||
if (!m.isValid()) {
|
||
return m.localeData().invalidDate()
|
||
}
|
||
format = expandFormat(format, m.localeData());
|
||
formatFunctions[format] = formatFunctions[format] || makeFormatFunction(format);
|
||
return formatFunctions[format](m)
|
||
}
|
||
function expandFormat(format, locale) {
|
||
var i = 5;
|
||
function replaceLongDateFormatTokens(input) {
|
||
return locale.longDateFormat(input) || input
|
||
}
|
||
localFormattingTokens.lastIndex = 0;
|
||
while (i >= 0 && localFormattingTokens.test(format)) {
|
||
format = format.replace(localFormattingTokens, replaceLongDateFormatTokens);
|
||
localFormattingTokens.lastIndex = 0;
|
||
i -= 1
|
||
}
|
||
return format
|
||
}
|
||
var match1 = /\d/;
|
||
// 0 - 9
|
||
var match2 = /\d\d/;
|
||
// 00 - 99
|
||
var match3 = /\d{3}/;
|
||
// 000 - 999
|
||
var match4 = /\d{4}/;
|
||
// 0000 - 9999
|
||
var match6 = /[+-]?\d{6}/;
|
||
// -999999 - 999999
|
||
var match1to2 = /\d\d?/;
|
||
// 0 - 99
|
||
var match3to4 = /\d\d\d\d?/;
|
||
// 999 - 9999
|
||
var match5to6 = /\d\d\d\d\d\d?/;
|
||
// 99999 - 999999
|
||
var match1to3 = /\d{1,3}/;
|
||
// 0 - 999
|
||
var match1to4 = /\d{1,4}/;
|
||
// 0 - 9999
|
||
var match1to6 = /[+-]?\d{1,6}/;
|
||
// -999999 - 999999
|
||
var matchUnsigned = /\d+/;
|
||
// 0 - inf
|
||
var matchSigned = /[+-]?\d+/;
|
||
// -inf - inf
|
||
var matchOffset = /Z|[+-]\d\d:?\d\d/gi;
|
||
// +00:00 -00:00 +0000 -0000 or Z
|
||
var matchShortOffset = /Z|[+-]\d\d(?::?\d\d)?/gi;
|
||
// +00 -00 +00:00 -00:00 +0000 -0000 or Z
|
||
var matchTimestamp = /[+-]?\d+(\.\d{1,3})?/;
|
||
// 123456789 123456789.123
|
||
// any word (or two) characters or numbers including two/three word month in arabic.
|
||
// includes scottish gaelic two word and hyphenated months
|
||
var matchWord = /[0-9]*['a-z\u00A0-\u05FF\u0700-\uD7FF\uF900-\uFDCF\uFDF0-\uFFEF]+|[\u0600-\u06FF\/]+(\s*?[\u0600-\u06FF]+){1,2}/i;
|
||
var regexes = {};
|
||
function addRegexToken(token, regex, strictRegex) {
|
||
regexes[token] = isFunction(regex) ? regex : function (isStrict, localeData) {
|
||
return isStrict && strictRegex ? strictRegex : regex
|
||
}
|
||
}
|
||
function getParseRegexForToken(token, config) {
|
||
if (!hasOwnProp(regexes, token)) {
|
||
return new RegExp(unescapeFormat(token))
|
||
}
|
||
return regexes[token](config._strict, config._locale)
|
||
}
|
||
// Code from http://stackoverflow.com/questions/3561493/is-there-a-regexp-escape-function-in-javascript
|
||
function unescapeFormat(s) {
|
||
return regexEscape(s.replace('\\', '').replace(/\\(\[)|\\(\])|\[([^\]\[]*)\]|\\(.)/g, function (matched, p1, p2, p3, p4) {
|
||
return p1 || p2 || p3 || p4
|
||
}))
|
||
}
|
||
function regexEscape(s) {
|
||
return s.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&')
|
||
}
|
||
var tokens = {};
|
||
function addParseToken(token, callback) {
|
||
var i, func = callback;
|
||
if (typeof token === 'string') {
|
||
token = [token]
|
||
}
|
||
if (typeof callback === 'number') {
|
||
func = function (input, array) {
|
||
array[callback] = toInt(input)
|
||
}
|
||
}
|
||
for (i = 0; i < token.length; i++) {
|
||
tokens[token[i]] = func
|
||
}
|
||
}
|
||
function addWeekParseToken(token, callback) {
|
||
addParseToken(token, function (input, array, config, token) {
|
||
config._w = config._w || {};
|
||
callback(input, config._w, config, token)
|
||
})
|
||
}
|
||
function addTimeToArrayFromToken(token, input, config) {
|
||
if (input != null && hasOwnProp(tokens, token)) {
|
||
tokens[token](input, config._a, config, token)
|
||
}
|
||
}
|
||
var YEAR = 0;
|
||
var MONTH = 1;
|
||
var DATE = 2;
|
||
var HOUR = 3;
|
||
var MINUTE = 4;
|
||
var SECOND = 5;
|
||
var MILLISECOND = 6;
|
||
var WEEK = 7;
|
||
var WEEKDAY = 8;
|
||
function daysInMonth(year, month) {
|
||
return new Date(Date.UTC(year, month + 1, 0)).getUTCDate()
|
||
}
|
||
// FORMATTING
|
||
addFormatToken('M', [
|
||
'MM',
|
||
2
|
||
], 'Mo', function () {
|
||
return this.month() + 1
|
||
});
|
||
addFormatToken('MMM', 0, 0, function (format) {
|
||
return this.localeData().monthsShort(this, format)
|
||
});
|
||
addFormatToken('MMMM', 0, 0, function (format) {
|
||
return this.localeData().months(this, format)
|
||
});
|
||
// ALIASES
|
||
addUnitAlias('month', 'M');
|
||
// PARSING
|
||
addRegexToken('M', match1to2);
|
||
addRegexToken('MM', match1to2, match2);
|
||
addRegexToken('MMM', function (isStrict, locale) {
|
||
return locale.monthsShortRegex(isStrict)
|
||
});
|
||
addRegexToken('MMMM', function (isStrict, locale) {
|
||
return locale.monthsRegex(isStrict)
|
||
});
|
||
addParseToken([
|
||
'M',
|
||
'MM'
|
||
], function (input, array) {
|
||
array[MONTH] = toInt(input) - 1
|
||
});
|
||
addParseToken([
|
||
'MMM',
|
||
'MMMM'
|
||
], function (input, array, config, token) {
|
||
var month = config._locale.monthsParse(input, token, config._strict);
|
||
// if we didn't find a month name, mark the date as invalid.
|
||
if (month != null) {
|
||
array[MONTH] = month
|
||
} else {
|
||
getParsingFlags(config).invalidMonth = input
|
||
}
|
||
});
|
||
// LOCALES
|
||
var MONTHS_IN_FORMAT = /D[oD]?(\[[^\[\]]*\]|\s+)+MMMM?/;
|
||
var defaultLocaleMonths = 'January_February_March_April_May_June_July_August_September_October_November_December'.split('_');
|
||
function localeMonths(m, format) {
|
||
return isArray(this._months) ? this._months[m.month()] : this._months[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()]
|
||
}
|
||
var defaultLocaleMonthsShort = 'Jan_Feb_Mar_Apr_May_Jun_Jul_Aug_Sep_Oct_Nov_Dec'.split('_');
|
||
function localeMonthsShort(m, format) {
|
||
return isArray(this._monthsShort) ? this._monthsShort[m.month()] : this._monthsShort[MONTHS_IN_FORMAT.test(format) ? 'format' : 'standalone'][m.month()]
|
||
}
|
||
function localeMonthsParse(monthName, format, strict) {
|
||
var i, mom, regex;
|
||
if (!this._monthsParse) {
|
||
this._monthsParse = [];
|
||
this._longMonthsParse = [];
|
||
this._shortMonthsParse = []
|
||
}
|
||
for (i = 0; i < 12; i++) {
|
||
// make the regex if we don't have it already
|
||
mom = create_utc__createUTC([
|
||
2000,
|
||
i
|
||
]);
|
||
if (strict && !this._longMonthsParse[i]) {
|
||
this._longMonthsParse[i] = new RegExp('^' + this.months(mom, '').replace('.', '') + '$', 'i');
|
||
this._shortMonthsParse[i] = new RegExp('^' + this.monthsShort(mom, '').replace('.', '') + '$', 'i')
|
||
}
|
||
if (!strict && !this._monthsParse[i]) {
|
||
regex = '^' + this.months(mom, '') + '|^' + this.monthsShort(mom, '');
|
||
this._monthsParse[i] = new RegExp(regex.replace('.', ''), 'i')
|
||
}
|
||
// test the regex
|
||
if (strict && format === 'MMMM' && this._longMonthsParse[i].test(monthName)) {
|
||
return i
|
||
} else if (strict && format === 'MMM' && this._shortMonthsParse[i].test(monthName)) {
|
||
return i
|
||
} else if (!strict && this._monthsParse[i].test(monthName)) {
|
||
return i
|
||
}
|
||
}
|
||
}
|
||
// MOMENTS
|
||
function setMonth(mom, value) {
|
||
var dayOfMonth;
|
||
if (!mom.isValid()) {
|
||
// No op
|
||
return mom
|
||
}
|
||
if (typeof value === 'string') {
|
||
if (/^\d+$/.test(value)) {
|
||
value = toInt(value)
|
||
} else {
|
||
value = mom.localeData().monthsParse(value);
|
||
// TODO: Another silent failure?
|
||
if (typeof value !== 'number') {
|
||
return mom
|
||
}
|
||
}
|
||
}
|
||
dayOfMonth = Math.min(mom.date(), daysInMonth(mom.year(), value));
|
||
mom._d['set' + (mom._isUTC ? 'UTC' : '') + 'Month'](value, dayOfMonth);
|
||
return mom
|
||
}
|
||
function getSetMonth(value) {
|
||
if (value != null) {
|
||
setMonth(this, value);
|
||
utils_hooks__hooks.updateOffset(this, true);
|
||
return this
|
||
} else {
|
||
return get_set__get(this, 'Month')
|
||
}
|
||
}
|
||
function getDaysInMonth() {
|
||
return daysInMonth(this.year(), this.month())
|
||
}
|
||
var defaultMonthsShortRegex = matchWord;
|
||
function monthsShortRegex(isStrict) {
|
||
if (this._monthsParseExact) {
|
||
if (!hasOwnProp(this, '_monthsRegex')) {
|
||
computeMonthsParse.call(this)
|
||
}
|
||
if (isStrict) {
|
||
return this._monthsShortStrictRegex
|
||
} else {
|
||
return this._monthsShortRegex
|
||
}
|
||
} else {
|
||
return this._monthsShortStrictRegex && isStrict ? this._monthsShortStrictRegex : this._monthsShortRegex
|
||
}
|
||
}
|
||
var defaultMonthsRegex = matchWord;
|
||
function monthsRegex(isStrict) {
|
||
if (this._monthsParseExact) {
|
||
if (!hasOwnProp(this, '_monthsRegex')) {
|
||
computeMonthsParse.call(this)
|
||
}
|
||
if (isStrict) {
|
||
return this._monthsStrictRegex
|
||
} else {
|
||
return this._monthsRegex
|
||
}
|
||
} else {
|
||
return this._monthsStrictRegex && isStrict ? this._monthsStrictRegex : this._monthsRegex
|
||
}
|
||
}
|
||
function computeMonthsParse() {
|
||
function cmpLenRev(a, b) {
|
||
return b.length - a.length
|
||
}
|
||
var shortPieces = [], longPieces = [], mixedPieces = [], i, mom;
|
||
for (i = 0; i < 12; i++) {
|
||
// make the regex if we don't have it already
|
||
mom = create_utc__createUTC([
|
||
2000,
|
||
i
|
||
]);
|
||
shortPieces.push(this.monthsShort(mom, ''));
|
||
longPieces.push(this.months(mom, ''));
|
||
mixedPieces.push(this.months(mom, ''));
|
||
mixedPieces.push(this.monthsShort(mom, ''))
|
||
}
|
||
// Sorting makes sure if one month (or abbr) is a prefix of another it
|
||
// will match the longer piece.
|
||
shortPieces.sort(cmpLenRev);
|
||
longPieces.sort(cmpLenRev);
|
||
mixedPieces.sort(cmpLenRev);
|
||
for (i = 0; i < 12; i++) {
|
||
shortPieces[i] = regexEscape(shortPieces[i]);
|
||
longPieces[i] = regexEscape(longPieces[i]);
|
||
mixedPieces[i] = regexEscape(mixedPieces[i])
|
||
}
|
||
this._monthsRegex = new RegExp('^(' + mixedPieces.join('|') + ')', 'i');
|
||
this._monthsShortRegex = this._monthsRegex;
|
||
this._monthsStrictRegex = new RegExp('^(' + longPieces.join('|') + ')$', 'i');
|
||
this._monthsShortStrictRegex = new RegExp('^(' + shortPieces.join('|') + ')$', 'i')
|
||
}
|
||
function checkOverflow(m) {
|
||
var overflow;
|
||
var a = m._a;
|
||
if (a && getParsingFlags(m).overflow === -2) {
|
||
overflow = a[MONTH] < 0 || a[MONTH] > 11 ? MONTH : a[DATE] < 1 || a[DATE] > daysInMonth(a[YEAR], a[MONTH]) ? DATE : a[HOUR] < 0 || a[HOUR] > 24 || a[HOUR] === 24 && (a[MINUTE] !== 0 || a[SECOND] !== 0 || a[MILLISECOND] !== 0) ? HOUR : a[MINUTE] < 0 || a[MINUTE] > 59 ? MINUTE : a[SECOND] < 0 || a[SECOND] > 59 ? SECOND : a[MILLISECOND] < 0 || a[MILLISECOND] > 999 ? MILLISECOND : -1;
|
||
if (getParsingFlags(m)._overflowDayOfYear && (overflow < YEAR || overflow > DATE)) {
|
||
overflow = DATE
|
||
}
|
||
if (getParsingFlags(m)._overflowWeeks && overflow === -1) {
|
||
overflow = WEEK
|
||
}
|
||
if (getParsingFlags(m)._overflowWeekday && overflow === -1) {
|
||
overflow = WEEKDAY
|
||
}
|
||
getParsingFlags(m).overflow = overflow
|
||
}
|
||
return m
|
||
}
|
||
// iso 8601 regex
|
||
// 0000-00-00 0000-W00 or 0000-W00-0 + T + 00 or 00:00 or 00:00:00 or 00:00:00.000 + +00:00 or +0000 or +00)
|
||
var extendedIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})-(?:\d\d-\d\d|W\d\d-\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?::\d\d(?::\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
|
||
var basicIsoRegex = /^\s*((?:[+-]\d{6}|\d{4})(?:\d\d\d\d|W\d\d\d|W\d\d|\d\d\d|\d\d))(?:(T| )(\d\d(?:\d\d(?:\d\d(?:[.,]\d+)?)?)?)([\+\-]\d\d(?::?\d\d)?|\s*Z)?)?/;
|
||
var tzRegex = /Z|[+-]\d\d(?::?\d\d)?/;
|
||
var isoDates = [
|
||
[
|
||
'YYYYYY-MM-DD',
|
||
/[+-]\d{6}-\d\d-\d\d/
|
||
],
|
||
[
|
||
'YYYY-MM-DD',
|
||
/\d{4}-\d\d-\d\d/
|
||
],
|
||
[
|
||
'GGGG-[W]WW-E',
|
||
/\d{4}-W\d\d-\d/
|
||
],
|
||
[
|
||
'GGGG-[W]WW',
|
||
/\d{4}-W\d\d/,
|
||
false
|
||
],
|
||
[
|
||
'YYYY-DDD',
|
||
/\d{4}-\d{3}/
|
||
],
|
||
[
|
||
'YYYY-MM',
|
||
/\d{4}-\d\d/,
|
||
false
|
||
],
|
||
[
|
||
'YYYYYYMMDD',
|
||
/[+-]\d{10}/
|
||
],
|
||
[
|
||
'YYYYMMDD',
|
||
/\d{8}/
|
||
],
|
||
// YYYYMM is NOT allowed by the standard
|
||
[
|
||
'GGGG[W]WWE',
|
||
/\d{4}W\d{3}/
|
||
],
|
||
[
|
||
'GGGG[W]WW',
|
||
/\d{4}W\d{2}/,
|
||
false
|
||
],
|
||
[
|
||
'YYYYDDD',
|
||
/\d{7}/
|
||
]
|
||
];
|
||
// iso time formats and regexes
|
||
var isoTimes = [
|
||
[
|
||
'HH:mm:ss.SSSS',
|
||
/\d\d:\d\d:\d\d\.\d+/
|
||
],
|
||
[
|
||
'HH:mm:ss,SSSS',
|
||
/\d\d:\d\d:\d\d,\d+/
|
||
],
|
||
[
|
||
'HH:mm:ss',
|
||
/\d\d:\d\d:\d\d/
|
||
],
|
||
[
|
||
'HH:mm',
|
||
/\d\d:\d\d/
|
||
],
|
||
[
|
||
'HHmmss.SSSS',
|
||
/\d\d\d\d\d\d\.\d+/
|
||
],
|
||
[
|
||
'HHmmss,SSSS',
|
||
/\d\d\d\d\d\d,\d+/
|
||
],
|
||
[
|
||
'HHmmss',
|
||
/\d\d\d\d\d\d/
|
||
],
|
||
[
|
||
'HHmm',
|
||
/\d\d\d\d/
|
||
],
|
||
[
|
||
'HH',
|
||
/\d\d/
|
||
]
|
||
];
|
||
var aspNetJsonRegex = /^\/?Date\((\-?\d+)/i;
|
||
// date from iso format
|
||
function configFromISO(config) {
|
||
var i, l, string = config._i, match = extendedIsoRegex.exec(string) || basicIsoRegex.exec(string), allowTime, dateFormat, timeFormat, tzFormat;
|
||
if (match) {
|
||
getParsingFlags(config).iso = true;
|
||
for (i = 0, l = isoDates.length; i < l; i++) {
|
||
if (isoDates[i][1].exec(match[1])) {
|
||
dateFormat = isoDates[i][0];
|
||
allowTime = isoDates[i][2] !== false;
|
||
break
|
||
}
|
||
}
|
||
if (dateFormat == null) {
|
||
config._isValid = false;
|
||
return
|
||
}
|
||
if (match[3]) {
|
||
for (i = 0, l = isoTimes.length; i < l; i++) {
|
||
if (isoTimes[i][1].exec(match[3])) {
|
||
// match[2] should be 'T' or space
|
||
timeFormat = (match[2] || ' ') + isoTimes[i][0];
|
||
break
|
||
}
|
||
}
|
||
if (timeFormat == null) {
|
||
config._isValid = false;
|
||
return
|
||
}
|
||
}
|
||
if (!allowTime && timeFormat != null) {
|
||
config._isValid = false;
|
||
return
|
||
}
|
||
if (match[4]) {
|
||
if (tzRegex.exec(match[4])) {
|
||
tzFormat = 'Z'
|
||
} else {
|
||
config._isValid = false;
|
||
return
|
||
}
|
||
}
|
||
config._f = dateFormat + (timeFormat || '') + (tzFormat || '');
|
||
configFromStringAndFormat(config)
|
||
} else {
|
||
config._isValid = false
|
||
}
|
||
}
|
||
// date from iso format or fallback
|
||
function configFromString(config) {
|
||
var matched = aspNetJsonRegex.exec(config._i);
|
||
if (matched !== null) {
|
||
config._d = new Date(+matched[1]);
|
||
return
|
||
}
|
||
configFromISO(config);
|
||
if (config._isValid === false) {
|
||
delete config._isValid;
|
||
utils_hooks__hooks.createFromInputFallback(config)
|
||
}
|
||
}
|
||
utils_hooks__hooks.createFromInputFallback = deprecate('moment construction falls back to js Date. This is ' + 'discouraged and will be removed in upcoming major ' + 'release. Please refer to ' + 'https://github.com/moment/moment/issues/1407 for more info.', function (config) {
|
||
config._d = new Date(config._i + (config._useUTC ? ' UTC' : ''))
|
||
});
|
||
function createDate(y, m, d, h, M, s, ms) {
|
||
//can't just apply() to create a date:
|
||
//http://stackoverflow.com/questions/181348/instantiating-a-javascript-object-by-calling-prototype-constructor-apply
|
||
var date = new Date(y, m, d, h, M, s, ms);
|
||
//the date constructor remaps years 0-99 to 1900-1999
|
||
if (y < 100 && y >= 0 && isFinite(date.getFullYear())) {
|
||
date.setFullYear(y)
|
||
}
|
||
return date
|
||
}
|
||
function createUTCDate(y) {
|
||
var date = new Date(Date.UTC.apply(null, arguments));
|
||
//the Date.UTC function remaps years 0-99 to 1900-1999
|
||
if (y < 100 && y >= 0 && isFinite(date.getUTCFullYear())) {
|
||
date.setUTCFullYear(y)
|
||
}
|
||
return date
|
||
}
|
||
// FORMATTING
|
||
addFormatToken('Y', 0, 0, function () {
|
||
var y = this.year();
|
||
return y <= 9999 ? '' + y : '+' + y
|
||
});
|
||
addFormatToken(0, [
|
||
'YY',
|
||
2
|
||
], 0, function () {
|
||
return this.year() % 100
|
||
});
|
||
addFormatToken(0, [
|
||
'YYYY',
|
||
4
|
||
], 0, 'year');
|
||
addFormatToken(0, [
|
||
'YYYYY',
|
||
5
|
||
], 0, 'year');
|
||
addFormatToken(0, [
|
||
'YYYYYY',
|
||
6,
|
||
true
|
||
], 0, 'year');
|
||
// ALIASES
|
||
addUnitAlias('year', 'y');
|
||
// PARSING
|
||
addRegexToken('Y', matchSigned);
|
||
addRegexToken('YY', match1to2, match2);
|
||
addRegexToken('YYYY', match1to4, match4);
|
||
addRegexToken('YYYYY', match1to6, match6);
|
||
addRegexToken('YYYYYY', match1to6, match6);
|
||
addParseToken([
|
||
'YYYYY',
|
||
'YYYYYY'
|
||
], YEAR);
|
||
addParseToken('YYYY', function (input, array) {
|
||
array[YEAR] = input.length === 2 ? utils_hooks__hooks.parseTwoDigitYear(input) : toInt(input)
|
||
});
|
||
addParseToken('YY', function (input, array) {
|
||
array[YEAR] = utils_hooks__hooks.parseTwoDigitYear(input)
|
||
});
|
||
addParseToken('Y', function (input, array) {
|
||
array[YEAR] = parseInt(input, 10)
|
||
});
|
||
// HELPERS
|
||
function daysInYear(year) {
|
||
return isLeapYear(year) ? 366 : 365
|
||
}
|
||
function isLeapYear(year) {
|
||
return year % 4 === 0 && year % 100 !== 0 || year % 400 === 0
|
||
}
|
||
// HOOKS
|
||
utils_hooks__hooks.parseTwoDigitYear = function (input) {
|
||
return toInt(input) + (toInt(input) > 68 ? 1900 : 2000)
|
||
};
|
||
// MOMENTS
|
||
var getSetYear = makeGetSet('FullYear', false);
|
||
function getIsLeapYear() {
|
||
return isLeapYear(this.year())
|
||
}
|
||
// start-of-first-week - start-of-year
|
||
function firstWeekOffset(year, dow, doy) {
|
||
var
|
||
// first-week day -- which january is always in the first week (4 for iso, 1 for other)
|
||
fwd = 7 + dow - doy,
|
||
// first-week day local weekday -- which local weekday is fwd
|
||
fwdlw = (7 + createUTCDate(year, 0, fwd).getUTCDay() - dow) % 7;
|
||
return -fwdlw + fwd - 1
|
||
}
|
||
//http://en.wikipedia.org/wiki/ISO_week_date#Calculating_a_date_given_the_year.2C_week_number_and_weekday
|
||
function dayOfYearFromWeeks(year, week, weekday, dow, doy) {
|
||
var localWeekday = (7 + weekday - dow) % 7, weekOffset = firstWeekOffset(year, dow, doy), dayOfYear = 1 + 7 * (week - 1) + localWeekday + weekOffset, resYear, resDayOfYear;
|
||
if (dayOfYear <= 0) {
|
||
resYear = year - 1;
|
||
resDayOfYear = daysInYear(resYear) + dayOfYear
|
||
} else if (dayOfYear > daysInYear(year)) {
|
||
resYear = year + 1;
|
||
resDayOfYear = dayOfYear - daysInYear(year)
|
||
} else {
|
||
resYear = year;
|
||
resDayOfYear = dayOfYear
|
||
}
|
||
return {
|
||
year: resYear,
|
||
dayOfYear: resDayOfYear
|
||
}
|
||
}
|
||
function weekOfYear(mom, dow, doy) {
|
||
var weekOffset = firstWeekOffset(mom.year(), dow, doy), week = Math.floor((mom.dayOfYear() - weekOffset - 1) / 7) + 1, resWeek, resYear;
|
||
if (week < 1) {
|
||
resYear = mom.year() - 1;
|
||
resWeek = week + weeksInYear(resYear, dow, doy)
|
||
} else if (week > weeksInYear(mom.year(), dow, doy)) {
|
||
resWeek = week - weeksInYear(mom.year(), dow, doy);
|
||
resYear = mom.year() + 1
|
||
} else {
|
||
resYear = mom.year();
|
||
resWeek = week
|
||
}
|
||
return {
|
||
week: resWeek,
|
||
year: resYear
|
||
}
|
||
}
|
||
function weeksInYear(year, dow, doy) {
|
||
var weekOffset = firstWeekOffset(year, dow, doy), weekOffsetNext = firstWeekOffset(year + 1, dow, doy);
|
||
return (daysInYear(year) - weekOffset + weekOffsetNext) / 7
|
||
}
|
||
// Pick the first defined of two or three arguments.
|
||
function defaults(a, b, c) {
|
||
if (a != null) {
|
||
return a
|
||
}
|
||
if (b != null) {
|
||
return b
|
||
}
|
||
return c
|
||
}
|
||
function currentDateArray(config) {
|
||
// hooks is actually the exported moment object
|
||
var nowValue = new Date(utils_hooks__hooks.now());
|
||
if (config._useUTC) {
|
||
return [
|
||
nowValue.getUTCFullYear(),
|
||
nowValue.getUTCMonth(),
|
||
nowValue.getUTCDate()
|
||
]
|
||
}
|
||
return [
|
||
nowValue.getFullYear(),
|
||
nowValue.getMonth(),
|
||
nowValue.getDate()
|
||
]
|
||
}
|
||
// convert an array to a date.
|
||
// the array should mirror the parameters below
|
||
// note: all values past the year are optional and will default to the lowest possible value.
|
||
// [year, month, day , hour, minute, second, millisecond]
|
||
function configFromArray(config) {
|
||
var i, date, input = [], currentDate, yearToUse;
|
||
if (config._d) {
|
||
return
|
||
}
|
||
currentDate = currentDateArray(config);
|
||
//compute day of the year from weeks and weekdays
|
||
if (config._w && config._a[DATE] == null && config._a[MONTH] == null) {
|
||
dayOfYearFromWeekInfo(config)
|
||
}
|
||
//if the day of the year is set, figure out what it is
|
||
if (config._dayOfYear) {
|
||
yearToUse = defaults(config._a[YEAR], currentDate[YEAR]);
|
||
if (config._dayOfYear > daysInYear(yearToUse)) {
|
||
getParsingFlags(config)._overflowDayOfYear = true
|
||
}
|
||
date = createUTCDate(yearToUse, 0, config._dayOfYear);
|
||
config._a[MONTH] = date.getUTCMonth();
|
||
config._a[DATE] = date.getUTCDate()
|
||
}
|
||
// Default to current date.
|
||
// * if no year, month, day of month are given, default to today
|
||
// * if day of month is given, default month and year
|
||
// * if month is given, default only year
|
||
// * if year is given, don't default anything
|
||
for (i = 0; i < 3 && config._a[i] == null; ++i) {
|
||
config._a[i] = input[i] = currentDate[i]
|
||
}
|
||
// Zero out whatever was not defaulted, including time
|
||
for (; i < 7; i++) {
|
||
config._a[i] = input[i] = config._a[i] == null ? i === 2 ? 1 : 0 : config._a[i]
|
||
}
|
||
// Check for 24:00:00.000
|
||
if (config._a[HOUR] === 24 && config._a[MINUTE] === 0 && config._a[SECOND] === 0 && config._a[MILLISECOND] === 0) {
|
||
config._nextDay = true;
|
||
config._a[HOUR] = 0
|
||
}
|
||
config._d = (config._useUTC ? createUTCDate : createDate).apply(null, input);
|
||
// Apply timezone offset from input. The actual utcOffset can be changed
|
||
// with parseZone.
|
||
if (config._tzm != null) {
|
||
config._d.setUTCMinutes(config._d.getUTCMinutes() - config._tzm)
|
||
}
|
||
if (config._nextDay) {
|
||
config._a[HOUR] = 24
|
||
}
|
||
}
|
||
function dayOfYearFromWeekInfo(config) {
|
||
var w, weekYear, week, weekday, dow, doy, temp, weekdayOverflow;
|
||
w = config._w;
|
||
if (w.GG != null || w.W != null || w.E != null) {
|
||
dow = 1;
|
||
doy = 4;
|
||
// TODO: We need to take the current isoWeekYear, but that depends on
|
||
// how we interpret now (local, utc, fixed offset). So create
|
||
// a now version of current config (take local/utc/offset flags, and
|
||
// create now).
|
||
weekYear = defaults(w.GG, config._a[YEAR], weekOfYear(local__createLocal(), 1, 4).year);
|
||
week = defaults(w.W, 1);
|
||
weekday = defaults(w.E, 1);
|
||
if (weekday < 1 || weekday > 7) {
|
||
weekdayOverflow = true
|
||
}
|
||
} else {
|
||
dow = config._locale._week.dow;
|
||
doy = config._locale._week.doy;
|
||
weekYear = defaults(w.gg, config._a[YEAR], weekOfYear(local__createLocal(), dow, doy).year);
|
||
week = defaults(w.w, 1);
|
||
if (w.d != null) {
|
||
// weekday -- low day numbers are considered next week
|
||
weekday = w.d;
|
||
if (weekday < 0 || weekday > 6) {
|
||
weekdayOverflow = true
|
||
}
|
||
} else if (w.e != null) {
|
||
// local weekday -- counting starts from begining of week
|
||
weekday = w.e + dow;
|
||
if (w.e < 0 || w.e > 6) {
|
||
weekdayOverflow = true
|
||
}
|
||
} else {
|
||
// default to begining of week
|
||
weekday = dow
|
||
}
|
||
}
|
||
if (week < 1 || week > weeksInYear(weekYear, dow, doy)) {
|
||
getParsingFlags(config)._overflowWeeks = true
|
||
} else if (weekdayOverflow != null) {
|
||
getParsingFlags(config)._overflowWeekday = true
|
||
} else {
|
||
temp = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy);
|
||
config._a[YEAR] = temp.year;
|
||
config._dayOfYear = temp.dayOfYear
|
||
}
|
||
}
|
||
// constant that refers to the ISO standard
|
||
utils_hooks__hooks.ISO_8601 = function () {
|
||
};
|
||
// date from string and format string
|
||
function configFromStringAndFormat(config) {
|
||
// TODO: Move this to another part of the creation flow to prevent circular deps
|
||
if (config._f === utils_hooks__hooks.ISO_8601) {
|
||
configFromISO(config);
|
||
return
|
||
}
|
||
config._a = [];
|
||
getParsingFlags(config).empty = true;
|
||
// This array is used to make a Date, either with `new Date` or `Date.UTC`
|
||
var string = '' + config._i, i, parsedInput, tokens, token, skipped, stringLength = string.length, totalParsedInputLength = 0;
|
||
tokens = expandFormat(config._f, config._locale).match(formattingTokens) || [];
|
||
for (i = 0; i < tokens.length; i++) {
|
||
token = tokens[i];
|
||
parsedInput = (string.match(getParseRegexForToken(token, config)) || [])[0];
|
||
// console.log('token', token, 'parsedInput', parsedInput,
|
||
// 'regex', getParseRegexForToken(token, config));
|
||
if (parsedInput) {
|
||
skipped = string.substr(0, string.indexOf(parsedInput));
|
||
if (skipped.length > 0) {
|
||
getParsingFlags(config).unusedInput.push(skipped)
|
||
}
|
||
string = string.slice(string.indexOf(parsedInput) + parsedInput.length);
|
||
totalParsedInputLength += parsedInput.length
|
||
}
|
||
// don't parse if it's not a known token
|
||
if (formatTokenFunctions[token]) {
|
||
if (parsedInput) {
|
||
getParsingFlags(config).empty = false
|
||
} else {
|
||
getParsingFlags(config).unusedTokens.push(token)
|
||
}
|
||
addTimeToArrayFromToken(token, parsedInput, config)
|
||
} else if (config._strict && !parsedInput) {
|
||
getParsingFlags(config).unusedTokens.push(token)
|
||
}
|
||
}
|
||
// add remaining unparsed input length to the string
|
||
getParsingFlags(config).charsLeftOver = stringLength - totalParsedInputLength;
|
||
if (string.length > 0) {
|
||
getParsingFlags(config).unusedInput.push(string)
|
||
}
|
||
// clear _12h flag if hour is <= 12
|
||
if (getParsingFlags(config).bigHour === true && config._a[HOUR] <= 12 && config._a[HOUR] > 0) {
|
||
getParsingFlags(config).bigHour = undefined
|
||
}
|
||
// handle meridiem
|
||
config._a[HOUR] = meridiemFixWrap(config._locale, config._a[HOUR], config._meridiem);
|
||
configFromArray(config);
|
||
checkOverflow(config)
|
||
}
|
||
function meridiemFixWrap(locale, hour, meridiem) {
|
||
var isPm;
|
||
if (meridiem == null) {
|
||
// nothing to do
|
||
return hour
|
||
}
|
||
if (locale.meridiemHour != null) {
|
||
return locale.meridiemHour(hour, meridiem)
|
||
} else if (locale.isPM != null) {
|
||
// Fallback
|
||
isPm = locale.isPM(meridiem);
|
||
if (isPm && hour < 12) {
|
||
hour += 12
|
||
}
|
||
if (!isPm && hour === 12) {
|
||
hour = 0
|
||
}
|
||
return hour
|
||
} else {
|
||
// this is not supposed to happen
|
||
return hour
|
||
}
|
||
}
|
||
// date from string and array of format strings
|
||
function configFromStringAndArray(config) {
|
||
var tempConfig, bestMoment, scoreToBeat, i, currentScore;
|
||
if (config._f.length === 0) {
|
||
getParsingFlags(config).invalidFormat = true;
|
||
config._d = new Date(NaN);
|
||
return
|
||
}
|
||
for (i = 0; i < config._f.length; i++) {
|
||
currentScore = 0;
|
||
tempConfig = copyConfig({}, config);
|
||
if (config._useUTC != null) {
|
||
tempConfig._useUTC = config._useUTC
|
||
}
|
||
tempConfig._f = config._f[i];
|
||
configFromStringAndFormat(tempConfig);
|
||
if (!valid__isValid(tempConfig)) {
|
||
continue
|
||
}
|
||
// if there is any input that was not parsed add a penalty for that format
|
||
currentScore += getParsingFlags(tempConfig).charsLeftOver;
|
||
//or tokens
|
||
currentScore += getParsingFlags(tempConfig).unusedTokens.length * 10;
|
||
getParsingFlags(tempConfig).score = currentScore;
|
||
if (scoreToBeat == null || currentScore < scoreToBeat) {
|
||
scoreToBeat = currentScore;
|
||
bestMoment = tempConfig
|
||
}
|
||
}
|
||
extend(config, bestMoment || tempConfig)
|
||
}
|
||
function configFromObject(config) {
|
||
if (config._d) {
|
||
return
|
||
}
|
||
var i = normalizeObjectUnits(config._i);
|
||
config._a = map([
|
||
i.year,
|
||
i.month,
|
||
i.day || i.date,
|
||
i.hour,
|
||
i.minute,
|
||
i.second,
|
||
i.millisecond
|
||
], function (obj) {
|
||
return obj && parseInt(obj, 10)
|
||
});
|
||
configFromArray(config)
|
||
}
|
||
function createFromConfig(config) {
|
||
var res = new Moment(checkOverflow(prepareConfig(config)));
|
||
if (res._nextDay) {
|
||
// Adding is smart enough around DST
|
||
res.add(1, 'd');
|
||
res._nextDay = undefined
|
||
}
|
||
return res
|
||
}
|
||
function prepareConfig(config) {
|
||
var input = config._i, format = config._f;
|
||
config._locale = config._locale || locale_locales__getLocale(config._l);
|
||
if (input === null || format === undefined && input === '') {
|
||
return valid__createInvalid({ nullInput: true })
|
||
}
|
||
if (typeof input === 'string') {
|
||
config._i = input = config._locale.preparse(input)
|
||
}
|
||
if (isMoment(input)) {
|
||
return new Moment(checkOverflow(input))
|
||
} else if (isArray(format)) {
|
||
configFromStringAndArray(config)
|
||
} else if (format) {
|
||
configFromStringAndFormat(config)
|
||
} else if (isDate(input)) {
|
||
config._d = input
|
||
} else {
|
||
configFromInput(config)
|
||
}
|
||
if (!valid__isValid(config)) {
|
||
config._d = null
|
||
}
|
||
return config
|
||
}
|
||
function configFromInput(config) {
|
||
var input = config._i;
|
||
if (input === undefined) {
|
||
config._d = new Date(utils_hooks__hooks.now())
|
||
} else if (isDate(input)) {
|
||
config._d = new Date(+input)
|
||
} else if (typeof input === 'string') {
|
||
configFromString(config)
|
||
} else if (isArray(input)) {
|
||
config._a = map(input.slice(0), function (obj) {
|
||
return parseInt(obj, 10)
|
||
});
|
||
configFromArray(config)
|
||
} else if (typeof input === 'object') {
|
||
configFromObject(config)
|
||
} else if (typeof input === 'number') {
|
||
// from milliseconds
|
||
config._d = new Date(input)
|
||
} else {
|
||
utils_hooks__hooks.createFromInputFallback(config)
|
||
}
|
||
}
|
||
function createLocalOrUTC(input, format, locale, strict, isUTC) {
|
||
var c = {};
|
||
if (typeof locale === 'boolean') {
|
||
strict = locale;
|
||
locale = undefined
|
||
}
|
||
// object construction must be done this way.
|
||
// https://github.com/moment/moment/issues/1423
|
||
c._isAMomentObject = true;
|
||
c._useUTC = c._isUTC = isUTC;
|
||
c._l = locale;
|
||
c._i = input;
|
||
c._f = format;
|
||
c._strict = strict;
|
||
return createFromConfig(c)
|
||
}
|
||
function local__createLocal(input, format, locale, strict) {
|
||
return createLocalOrUTC(input, format, locale, strict, false)
|
||
}
|
||
var prototypeMin = deprecate('moment().min is deprecated, use moment.max instead. https://github.com/moment/moment/issues/1548', function () {
|
||
var other = local__createLocal.apply(null, arguments);
|
||
if (this.isValid() && other.isValid()) {
|
||
return other < this ? this : other
|
||
} else {
|
||
return valid__createInvalid()
|
||
}
|
||
});
|
||
var prototypeMax = deprecate('moment().max is deprecated, use moment.min instead. https://github.com/moment/moment/issues/1548', function () {
|
||
var other = local__createLocal.apply(null, arguments);
|
||
if (this.isValid() && other.isValid()) {
|
||
return other > this ? this : other
|
||
} else {
|
||
return valid__createInvalid()
|
||
}
|
||
});
|
||
// Pick a moment m from moments so that m[fn](other) is true for all
|
||
// other. This relies on the function fn to be transitive.
|
||
//
|
||
// moments should either be an array of moment objects or an array, whose
|
||
// first element is an array of moment objects.
|
||
function pickBy(fn, moments) {
|
||
var res, i;
|
||
if (moments.length === 1 && isArray(moments[0])) {
|
||
moments = moments[0]
|
||
}
|
||
if (!moments.length) {
|
||
return local__createLocal()
|
||
}
|
||
res = moments[0];
|
||
for (i = 1; i < moments.length; ++i) {
|
||
if (!moments[i].isValid() || moments[i][fn](res)) {
|
||
res = moments[i]
|
||
}
|
||
}
|
||
return res
|
||
}
|
||
// TODO: Use [].sort instead?
|
||
function min() {
|
||
var args = [].slice.call(arguments, 0);
|
||
return pickBy('isBefore', args)
|
||
}
|
||
function max() {
|
||
var args = [].slice.call(arguments, 0);
|
||
return pickBy('isAfter', args)
|
||
}
|
||
var now = function () {
|
||
return Date.now ? Date.now() : +new Date
|
||
};
|
||
function Duration(duration) {
|
||
var normalizedInput = normalizeObjectUnits(duration), years = normalizedInput.year || 0, quarters = normalizedInput.quarter || 0, months = normalizedInput.month || 0, weeks = normalizedInput.week || 0, days = normalizedInput.day || 0, hours = normalizedInput.hour || 0, minutes = normalizedInput.minute || 0, seconds = normalizedInput.second || 0, milliseconds = normalizedInput.millisecond || 0;
|
||
// representation for dateAddRemove
|
||
this._milliseconds = +milliseconds + seconds * 1000 + // 1000
|
||
minutes * 60000 + // 1000 * 60
|
||
hours * 3600000;
|
||
// 1000 * 60 * 60
|
||
// Because of dateAddRemove treats 24 hours as different from a
|
||
// day when working around DST, we need to store them separately
|
||
this._days = +days + weeks * 7;
|
||
// It is impossible translate months into days without knowing
|
||
// which months you are are talking about, so we have to store
|
||
// it separately.
|
||
this._months = +months + quarters * 3 + years * 12;
|
||
this._data = {};
|
||
this._locale = locale_locales__getLocale();
|
||
this._bubble()
|
||
}
|
||
function isDuration(obj) {
|
||
return obj instanceof Duration
|
||
}
|
||
// FORMATTING
|
||
function offset(token, separator) {
|
||
addFormatToken(token, 0, 0, function () {
|
||
var offset = this.utcOffset();
|
||
var sign = '+';
|
||
if (offset < 0) {
|
||
offset = -offset;
|
||
sign = '-'
|
||
}
|
||
return sign + zeroFill(~~(offset / 60), 2) + separator + zeroFill(~~offset % 60, 2)
|
||
})
|
||
}
|
||
offset('Z', ':');
|
||
offset('ZZ', '');
|
||
// PARSING
|
||
addRegexToken('Z', matchShortOffset);
|
||
addRegexToken('ZZ', matchShortOffset);
|
||
addParseToken([
|
||
'Z',
|
||
'ZZ'
|
||
], function (input, array, config) {
|
||
config._useUTC = true;
|
||
config._tzm = offsetFromString(matchShortOffset, input)
|
||
});
|
||
// HELPERS
|
||
// timezone chunker
|
||
// '+10:00' > ['10', '00']
|
||
// '-1530' > ['-15', '30']
|
||
var chunkOffset = /([\+\-]|\d\d)/gi;
|
||
function offsetFromString(matcher, string) {
|
||
var matches = (string || '').match(matcher) || [];
|
||
var chunk = matches[matches.length - 1] || [];
|
||
var parts = (chunk + '').match(chunkOffset) || [
|
||
'-',
|
||
0,
|
||
0
|
||
];
|
||
var minutes = +(parts[1] * 60) + toInt(parts[2]);
|
||
return parts[0] === '+' ? minutes : -minutes
|
||
}
|
||
// Return a moment from input, that is local/utc/zone equivalent to model.
|
||
function cloneWithOffset(input, model) {
|
||
var res, diff;
|
||
if (model._isUTC) {
|
||
res = model.clone();
|
||
diff = (isMoment(input) || isDate(input) ? +input : +local__createLocal(input)) - +res;
|
||
// Use low-level api, because this fn is low-level api.
|
||
res._d.setTime(+res._d + diff);
|
||
utils_hooks__hooks.updateOffset(res, false);
|
||
return res
|
||
} else {
|
||
return local__createLocal(input).local()
|
||
}
|
||
}
|
||
function getDateOffset(m) {
|
||
// On Firefox.24 Date#getTimezoneOffset returns a floating point.
|
||
// https://github.com/moment/moment/pull/1871
|
||
return -Math.round(m._d.getTimezoneOffset() / 15) * 15
|
||
}
|
||
// HOOKS
|
||
// This function will be called whenever a moment is mutated.
|
||
// It is intended to keep the offset in sync with the timezone.
|
||
utils_hooks__hooks.updateOffset = function () {
|
||
};
|
||
// MOMENTS
|
||
// keepLocalTime = true means only change the timezone, without
|
||
// affecting the local hour. So 5:31:26 +0300 --[utcOffset(2, true)]-->
|
||
// 5:31:26 +0200 It is possible that 5:31:26 doesn't exist with offset
|
||
// +0200, so we adjust the time as needed, to be valid.
|
||
//
|
||
// Keeping the time actually adds/subtracts (one hour)
|
||
// from the actual represented time. That is why we call updateOffset
|
||
// a second time. In case it wants us to change the offset again
|
||
// _changeInProgress == true case, then we have to adjust, because
|
||
// there is no such time in the given timezone.
|
||
function getSetOffset(input, keepLocalTime) {
|
||
var offset = this._offset || 0, localAdjust;
|
||
if (!this.isValid()) {
|
||
return input != null ? this : NaN
|
||
}
|
||
if (input != null) {
|
||
if (typeof input === 'string') {
|
||
input = offsetFromString(matchShortOffset, input)
|
||
} else if (Math.abs(input) < 16) {
|
||
input = input * 60
|
||
}
|
||
if (!this._isUTC && keepLocalTime) {
|
||
localAdjust = getDateOffset(this)
|
||
}
|
||
this._offset = input;
|
||
this._isUTC = true;
|
||
if (localAdjust != null) {
|
||
this.add(localAdjust, 'm')
|
||
}
|
||
if (offset !== input) {
|
||
if (!keepLocalTime || this._changeInProgress) {
|
||
add_subtract__addSubtract(this, create__createDuration(input - offset, 'm'), 1, false)
|
||
} else if (!this._changeInProgress) {
|
||
this._changeInProgress = true;
|
||
utils_hooks__hooks.updateOffset(this, true);
|
||
this._changeInProgress = null
|
||
}
|
||
}
|
||
return this
|
||
} else {
|
||
return this._isUTC ? offset : getDateOffset(this)
|
||
}
|
||
}
|
||
function getSetZone(input, keepLocalTime) {
|
||
if (input != null) {
|
||
if (typeof input !== 'string') {
|
||
input = -input
|
||
}
|
||
this.utcOffset(input, keepLocalTime);
|
||
return this
|
||
} else {
|
||
return -this.utcOffset()
|
||
}
|
||
}
|
||
function setOffsetToUTC(keepLocalTime) {
|
||
return this.utcOffset(0, keepLocalTime)
|
||
}
|
||
function setOffsetToLocal(keepLocalTime) {
|
||
if (this._isUTC) {
|
||
this.utcOffset(0, keepLocalTime);
|
||
this._isUTC = false;
|
||
if (keepLocalTime) {
|
||
this.subtract(getDateOffset(this), 'm')
|
||
}
|
||
}
|
||
return this
|
||
}
|
||
function setOffsetToParsedOffset() {
|
||
if (this._tzm) {
|
||
this.utcOffset(this._tzm)
|
||
} else if (typeof this._i === 'string') {
|
||
this.utcOffset(offsetFromString(matchOffset, this._i))
|
||
}
|
||
return this
|
||
}
|
||
function hasAlignedHourOffset(input) {
|
||
if (!this.isValid()) {
|
||
return false
|
||
}
|
||
input = input ? local__createLocal(input).utcOffset() : 0;
|
||
return (this.utcOffset() - input) % 60 === 0
|
||
}
|
||
function isDaylightSavingTime() {
|
||
return this.utcOffset() > this.clone().month(0).utcOffset() || this.utcOffset() > this.clone().month(5).utcOffset()
|
||
}
|
||
function isDaylightSavingTimeShifted() {
|
||
if (!isUndefined(this._isDSTShifted)) {
|
||
return this._isDSTShifted
|
||
}
|
||
var c = {};
|
||
copyConfig(c, this);
|
||
c = prepareConfig(c);
|
||
if (c._a) {
|
||
var other = c._isUTC ? create_utc__createUTC(c._a) : local__createLocal(c._a);
|
||
this._isDSTShifted = this.isValid() && compareArrays(c._a, other.toArray()) > 0
|
||
} else {
|
||
this._isDSTShifted = false
|
||
}
|
||
return this._isDSTShifted
|
||
}
|
||
function isLocal() {
|
||
return this.isValid() ? !this._isUTC : false
|
||
}
|
||
function isUtcOffset() {
|
||
return this.isValid() ? this._isUTC : false
|
||
}
|
||
function isUtc() {
|
||
return this.isValid() ? this._isUTC && this._offset === 0 : false
|
||
}
|
||
// ASP.NET json date format regex
|
||
var aspNetRegex = /^(\-)?(?:(\d*)[. ])?(\d+)\:(\d+)(?:\:(\d+)\.?(\d{3})?\d*)?$/;
|
||
// from http://docs.closure-library.googlecode.com/git/closure_goog_date_date.js.source.html
|
||
// somewhat more in line with 4.4.3.2 2004 spec, but allows decimal anywhere
|
||
// and further modified to allow for strings containing both week and day
|
||
var isoRegex = /^(-)?P(?:([0-9,.]*)Y)?(?:([0-9,.]*)M)?(?:([0-9,.]*)W)?(?:([0-9,.]*)D)?(?:T(?:([0-9,.]*)H)?(?:([0-9,.]*)M)?(?:([0-9,.]*)S)?)?$/;
|
||
function create__createDuration(input, key) {
|
||
var duration = input,
|
||
// matching against regexp is expensive, do it on demand
|
||
match = null, sign, ret, diffRes;
|
||
if (isDuration(input)) {
|
||
duration = {
|
||
ms: input._milliseconds,
|
||
d: input._days,
|
||
M: input._months
|
||
}
|
||
} else if (typeof input === 'number') {
|
||
duration = {};
|
||
if (key) {
|
||
duration[key] = input
|
||
} else {
|
||
duration.milliseconds = input
|
||
}
|
||
} else if (!!(match = aspNetRegex.exec(input))) {
|
||
sign = match[1] === '-' ? -1 : 1;
|
||
duration = {
|
||
y: 0,
|
||
d: toInt(match[DATE]) * sign,
|
||
h: toInt(match[HOUR]) * sign,
|
||
m: toInt(match[MINUTE]) * sign,
|
||
s: toInt(match[SECOND]) * sign,
|
||
ms: toInt(match[MILLISECOND]) * sign
|
||
}
|
||
} else if (!!(match = isoRegex.exec(input))) {
|
||
sign = match[1] === '-' ? -1 : 1;
|
||
duration = {
|
||
y: parseIso(match[2], sign),
|
||
M: parseIso(match[3], sign),
|
||
w: parseIso(match[4], sign),
|
||
d: parseIso(match[5], sign),
|
||
h: parseIso(match[6], sign),
|
||
m: parseIso(match[7], sign),
|
||
s: parseIso(match[8], sign)
|
||
}
|
||
} else if (duration == null) {
|
||
// checks for null or undefined
|
||
duration = {}
|
||
} else if (typeof duration === 'object' && ('from' in duration || 'to' in duration)) {
|
||
diffRes = momentsDifference(local__createLocal(duration.from), local__createLocal(duration.to));
|
||
duration = {};
|
||
duration.ms = diffRes.milliseconds;
|
||
duration.M = diffRes.months
|
||
}
|
||
ret = new Duration(duration);
|
||
if (isDuration(input) && hasOwnProp(input, '_locale')) {
|
||
ret._locale = input._locale
|
||
}
|
||
return ret
|
||
}
|
||
create__createDuration.fn = Duration.prototype;
|
||
function parseIso(inp, sign) {
|
||
// We'd normally use ~~inp for this, but unfortunately it also
|
||
// converts floats to ints.
|
||
// inp may be undefined, so careful calling replace on it.
|
||
var res = inp && parseFloat(inp.replace(',', '.'));
|
||
// apply sign while we're at it
|
||
return (isNaN(res) ? 0 : res) * sign
|
||
}
|
||
function positiveMomentsDifference(base, other) {
|
||
var res = {
|
||
milliseconds: 0,
|
||
months: 0
|
||
};
|
||
res.months = other.month() - base.month() + (other.year() - base.year()) * 12;
|
||
if (base.clone().add(res.months, 'M').isAfter(other)) {
|
||
--res.months
|
||
}
|
||
res.milliseconds = +other - +base.clone().add(res.months, 'M');
|
||
return res
|
||
}
|
||
function momentsDifference(base, other) {
|
||
var res;
|
||
if (!(base.isValid() && other.isValid())) {
|
||
return {
|
||
milliseconds: 0,
|
||
months: 0
|
||
}
|
||
}
|
||
other = cloneWithOffset(other, base);
|
||
if (base.isBefore(other)) {
|
||
res = positiveMomentsDifference(base, other)
|
||
} else {
|
||
res = positiveMomentsDifference(other, base);
|
||
res.milliseconds = -res.milliseconds;
|
||
res.months = -res.months
|
||
}
|
||
return res
|
||
}
|
||
function absRound(number) {
|
||
if (number < 0) {
|
||
return Math.round(-1 * number) * -1
|
||
} else {
|
||
return Math.round(number)
|
||
}
|
||
}
|
||
// TODO: remove 'name' arg after deprecation is removed
|
||
function createAdder(direction, name) {
|
||
return function (val, period) {
|
||
var dur, tmp;
|
||
//invert the arguments, but complain about it
|
||
if (period !== null && !isNaN(+period)) {
|
||
deprecateSimple(name, 'moment().' + name + '(period, number) is deprecated. Please use moment().' + name + '(number, period).');
|
||
tmp = val;
|
||
val = period;
|
||
period = tmp
|
||
}
|
||
val = typeof val === 'string' ? +val : val;
|
||
dur = create__createDuration(val, period);
|
||
add_subtract__addSubtract(this, dur, direction);
|
||
return this
|
||
}
|
||
}
|
||
function add_subtract__addSubtract(mom, duration, isAdding, updateOffset) {
|
||
var milliseconds = duration._milliseconds, days = absRound(duration._days), months = absRound(duration._months);
|
||
if (!mom.isValid()) {
|
||
// No op
|
||
return
|
||
}
|
||
updateOffset = updateOffset == null ? true : updateOffset;
|
||
if (milliseconds) {
|
||
mom._d.setTime(+mom._d + milliseconds * isAdding)
|
||
}
|
||
if (days) {
|
||
get_set__set(mom, 'Date', get_set__get(mom, 'Date') + days * isAdding)
|
||
}
|
||
if (months) {
|
||
setMonth(mom, get_set__get(mom, 'Month') + months * isAdding)
|
||
}
|
||
if (updateOffset) {
|
||
utils_hooks__hooks.updateOffset(mom, days || months)
|
||
}
|
||
}
|
||
var add_subtract__add = createAdder(1, 'add');
|
||
var add_subtract__subtract = createAdder(-1, 'subtract');
|
||
function moment_calendar__calendar(time, formats) {
|
||
// We want to compare the start of today, vs this.
|
||
// Getting start-of-today depends on whether we're local/utc/offset or not.
|
||
var now = time || local__createLocal(), sod = cloneWithOffset(now, this).startOf('day'), diff = this.diff(sod, 'days', true), format = diff < -6 ? 'sameElse' : diff < -1 ? 'lastWeek' : diff < 0 ? 'lastDay' : diff < 1 ? 'sameDay' : diff < 2 ? 'nextDay' : diff < 7 ? 'nextWeek' : 'sameElse';
|
||
var output = formats && (isFunction(formats[format]) ? formats[format]() : formats[format]);
|
||
return this.format(output || this.localeData().calendar(format, this, local__createLocal(now)))
|
||
}
|
||
function clone() {
|
||
return new Moment(this)
|
||
}
|
||
function isAfter(input, units) {
|
||
var localInput = isMoment(input) ? input : local__createLocal(input);
|
||
if (!(this.isValid() && localInput.isValid())) {
|
||
return false
|
||
}
|
||
units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
|
||
if (units === 'millisecond') {
|
||
return +this > +localInput
|
||
} else {
|
||
return +localInput < +this.clone().startOf(units)
|
||
}
|
||
}
|
||
function isBefore(input, units) {
|
||
var localInput = isMoment(input) ? input : local__createLocal(input);
|
||
if (!(this.isValid() && localInput.isValid())) {
|
||
return false
|
||
}
|
||
units = normalizeUnits(!isUndefined(units) ? units : 'millisecond');
|
||
if (units === 'millisecond') {
|
||
return +this < +localInput
|
||
} else {
|
||
return +this.clone().endOf(units) < +localInput
|
||
}
|
||
}
|
||
function isBetween(from, to, units) {
|
||
return this.isAfter(from, units) && this.isBefore(to, units)
|
||
}
|
||
function isSame(input, units) {
|
||
var localInput = isMoment(input) ? input : local__createLocal(input), inputMs;
|
||
if (!(this.isValid() && localInput.isValid())) {
|
||
return false
|
||
}
|
||
units = normalizeUnits(units || 'millisecond');
|
||
if (units === 'millisecond') {
|
||
return +this === +localInput
|
||
} else {
|
||
inputMs = +localInput;
|
||
return +this.clone().startOf(units) <= inputMs && inputMs <= +this.clone().endOf(units)
|
||
}
|
||
}
|
||
function isSameOrAfter(input, units) {
|
||
return this.isSame(input, units) || this.isAfter(input, units)
|
||
}
|
||
function isSameOrBefore(input, units) {
|
||
return this.isSame(input, units) || this.isBefore(input, units)
|
||
}
|
||
function diff(input, units, asFloat) {
|
||
var that, zoneDelta, delta, output;
|
||
if (!this.isValid()) {
|
||
return NaN
|
||
}
|
||
that = cloneWithOffset(input, this);
|
||
if (!that.isValid()) {
|
||
return NaN
|
||
}
|
||
zoneDelta = (that.utcOffset() - this.utcOffset()) * 60000;
|
||
units = normalizeUnits(units);
|
||
if (units === 'year' || units === 'month' || units === 'quarter') {
|
||
output = monthDiff(this, that);
|
||
if (units === 'quarter') {
|
||
output = output / 3
|
||
} else if (units === 'year') {
|
||
output = output / 12
|
||
}
|
||
} else {
|
||
delta = this - that;
|
||
output = units === 'second' ? delta / 1000 : // 1000
|
||
units === 'minute' ? delta / 60000 : // 1000 * 60
|
||
units === 'hour' ? delta / 3600000 : // 1000 * 60 * 60
|
||
units === 'day' ? (delta - zoneDelta) / 86400000 : // 1000 * 60 * 60 * 24, negate dst
|
||
units === 'week' ? (delta - zoneDelta) / 604800000 : // 1000 * 60 * 60 * 24 * 7, negate dst
|
||
delta
|
||
}
|
||
return asFloat ? output : absFloor(output)
|
||
}
|
||
function monthDiff(a, b) {
|
||
// difference in months
|
||
var wholeMonthDiff = (b.year() - a.year()) * 12 + (b.month() - a.month()),
|
||
// b is in (anchor - 1 month, anchor + 1 month)
|
||
anchor = a.clone().add(wholeMonthDiff, 'months'), anchor2, adjust;
|
||
if (b - anchor < 0) {
|
||
anchor2 = a.clone().add(wholeMonthDiff - 1, 'months');
|
||
// linear across the month
|
||
adjust = (b - anchor) / (anchor - anchor2)
|
||
} else {
|
||
anchor2 = a.clone().add(wholeMonthDiff + 1, 'months');
|
||
// linear across the month
|
||
adjust = (b - anchor) / (anchor2 - anchor)
|
||
}
|
||
return -(wholeMonthDiff + adjust)
|
||
}
|
||
utils_hooks__hooks.defaultFormat = 'YYYY-MM-DDTHH:mm:ssZ';
|
||
function toString() {
|
||
return this.clone().locale('en').format('ddd MMM DD YYYY HH:mm:ss [GMT]ZZ')
|
||
}
|
||
function moment_format__toISOString() {
|
||
var m = this.clone().utc();
|
||
if (0 < m.year() && m.year() <= 9999) {
|
||
if (isFunction(Date.prototype.toISOString)) {
|
||
// native implementation is ~50x faster, use it when we can
|
||
return this.toDate().toISOString()
|
||
} else {
|
||
return formatMoment(m, 'YYYY-MM-DD[T]HH:mm:ss.SSS[Z]')
|
||
}
|
||
} else {
|
||
return formatMoment(m, 'YYYYYY-MM-DD[T]HH:mm:ss.SSS[Z]')
|
||
}
|
||
}
|
||
function format(inputString) {
|
||
var output = formatMoment(this, inputString || utils_hooks__hooks.defaultFormat);
|
||
return this.localeData().postformat(output)
|
||
}
|
||
function from(time, withoutSuffix) {
|
||
if (this.isValid() && (isMoment(time) && time.isValid() || local__createLocal(time).isValid())) {
|
||
return create__createDuration({
|
||
to: this,
|
||
from: time
|
||
}).locale(this.locale()).humanize(!withoutSuffix)
|
||
} else {
|
||
return this.localeData().invalidDate()
|
||
}
|
||
}
|
||
function fromNow(withoutSuffix) {
|
||
return this.from(local__createLocal(), withoutSuffix)
|
||
}
|
||
function to(time, withoutSuffix) {
|
||
if (this.isValid() && (isMoment(time) && time.isValid() || local__createLocal(time).isValid())) {
|
||
return create__createDuration({
|
||
from: this,
|
||
to: time
|
||
}).locale(this.locale()).humanize(!withoutSuffix)
|
||
} else {
|
||
return this.localeData().invalidDate()
|
||
}
|
||
}
|
||
function toNow(withoutSuffix) {
|
||
return this.to(local__createLocal(), withoutSuffix)
|
||
}
|
||
// If passed a locale key, it will set the locale for this
|
||
// instance. Otherwise, it will return the locale configuration
|
||
// variables for this instance.
|
||
function locale(key) {
|
||
var newLocaleData;
|
||
if (key === undefined) {
|
||
return this._locale._abbr
|
||
} else {
|
||
newLocaleData = locale_locales__getLocale(key);
|
||
if (newLocaleData != null) {
|
||
this._locale = newLocaleData
|
||
}
|
||
return this
|
||
}
|
||
}
|
||
var lang = deprecate('moment().lang() is deprecated. Instead, use moment().localeData() to get the language configuration. Use moment().locale() to change languages.', function (key) {
|
||
if (key === undefined) {
|
||
return this.localeData()
|
||
} else {
|
||
return this.locale(key)
|
||
}
|
||
});
|
||
function localeData() {
|
||
return this._locale
|
||
}
|
||
function startOf(units) {
|
||
units = normalizeUnits(units);
|
||
// the following switch intentionally omits break keywords
|
||
// to utilize falling through the cases.
|
||
switch (units) {
|
||
case 'year':
|
||
this.month(0);
|
||
/* falls through */
|
||
case 'quarter':
|
||
case 'month':
|
||
this.date(1);
|
||
/* falls through */
|
||
case 'week':
|
||
case 'isoWeek':
|
||
case 'day':
|
||
this.hours(0);
|
||
/* falls through */
|
||
case 'hour':
|
||
this.minutes(0);
|
||
/* falls through */
|
||
case 'minute':
|
||
this.seconds(0);
|
||
/* falls through */
|
||
case 'second':
|
||
this.milliseconds(0)
|
||
}
|
||
// weeks are a special case
|
||
if (units === 'week') {
|
||
this.weekday(0)
|
||
}
|
||
if (units === 'isoWeek') {
|
||
this.isoWeekday(1)
|
||
}
|
||
// quarters are also special
|
||
if (units === 'quarter') {
|
||
this.month(Math.floor(this.month() / 3) * 3)
|
||
}
|
||
return this
|
||
}
|
||
function endOf(units) {
|
||
units = normalizeUnits(units);
|
||
if (units === undefined || units === 'millisecond') {
|
||
return this
|
||
}
|
||
return this.startOf(units).add(1, units === 'isoWeek' ? 'week' : units).subtract(1, 'ms')
|
||
}
|
||
function to_type__valueOf() {
|
||
return +this._d - (this._offset || 0) * 60000
|
||
}
|
||
function unix() {
|
||
return Math.floor(+this / 1000)
|
||
}
|
||
function toDate() {
|
||
return this._offset ? new Date(+this) : this._d
|
||
}
|
||
function toArray() {
|
||
var m = this;
|
||
return [
|
||
m.year(),
|
||
m.month(),
|
||
m.date(),
|
||
m.hour(),
|
||
m.minute(),
|
||
m.second(),
|
||
m.millisecond()
|
||
]
|
||
}
|
||
function toObject() {
|
||
var m = this;
|
||
return {
|
||
years: m.year(),
|
||
months: m.month(),
|
||
date: m.date(),
|
||
hours: m.hours(),
|
||
minutes: m.minutes(),
|
||
seconds: m.seconds(),
|
||
milliseconds: m.milliseconds()
|
||
}
|
||
}
|
||
function toJSON() {
|
||
// new Date(NaN).toJSON() === null
|
||
return this.isValid() ? this.toISOString() : null
|
||
}
|
||
function moment_valid__isValid() {
|
||
return valid__isValid(this)
|
||
}
|
||
function parsingFlags() {
|
||
return extend({}, getParsingFlags(this))
|
||
}
|
||
function invalidAt() {
|
||
return getParsingFlags(this).overflow
|
||
}
|
||
function creationData() {
|
||
return {
|
||
input: this._i,
|
||
format: this._f,
|
||
locale: this._locale,
|
||
isUTC: this._isUTC,
|
||
strict: this._strict
|
||
}
|
||
}
|
||
// FORMATTING
|
||
addFormatToken(0, [
|
||
'gg',
|
||
2
|
||
], 0, function () {
|
||
return this.weekYear() % 100
|
||
});
|
||
addFormatToken(0, [
|
||
'GG',
|
||
2
|
||
], 0, function () {
|
||
return this.isoWeekYear() % 100
|
||
});
|
||
function addWeekYearFormatToken(token, getter) {
|
||
addFormatToken(0, [
|
||
token,
|
||
token.length
|
||
], 0, getter)
|
||
}
|
||
addWeekYearFormatToken('gggg', 'weekYear');
|
||
addWeekYearFormatToken('ggggg', 'weekYear');
|
||
addWeekYearFormatToken('GGGG', 'isoWeekYear');
|
||
addWeekYearFormatToken('GGGGG', 'isoWeekYear');
|
||
// ALIASES
|
||
addUnitAlias('weekYear', 'gg');
|
||
addUnitAlias('isoWeekYear', 'GG');
|
||
// PARSING
|
||
addRegexToken('G', matchSigned);
|
||
addRegexToken('g', matchSigned);
|
||
addRegexToken('GG', match1to2, match2);
|
||
addRegexToken('gg', match1to2, match2);
|
||
addRegexToken('GGGG', match1to4, match4);
|
||
addRegexToken('gggg', match1to4, match4);
|
||
addRegexToken('GGGGG', match1to6, match6);
|
||
addRegexToken('ggggg', match1to6, match6);
|
||
addWeekParseToken([
|
||
'gggg',
|
||
'ggggg',
|
||
'GGGG',
|
||
'GGGGG'
|
||
], function (input, week, config, token) {
|
||
week[token.substr(0, 2)] = toInt(input)
|
||
});
|
||
addWeekParseToken([
|
||
'gg',
|
||
'GG'
|
||
], function (input, week, config, token) {
|
||
week[token] = utils_hooks__hooks.parseTwoDigitYear(input)
|
||
});
|
||
// MOMENTS
|
||
function getSetWeekYear(input) {
|
||
return getSetWeekYearHelper.call(this, input, this.week(), this.weekday(), this.localeData()._week.dow, this.localeData()._week.doy)
|
||
}
|
||
function getSetISOWeekYear(input) {
|
||
return getSetWeekYearHelper.call(this, input, this.isoWeek(), this.isoWeekday(), 1, 4)
|
||
}
|
||
function getISOWeeksInYear() {
|
||
return weeksInYear(this.year(), 1, 4)
|
||
}
|
||
function getWeeksInYear() {
|
||
var weekInfo = this.localeData()._week;
|
||
return weeksInYear(this.year(), weekInfo.dow, weekInfo.doy)
|
||
}
|
||
function getSetWeekYearHelper(input, week, weekday, dow, doy) {
|
||
var weeksTarget;
|
||
if (input == null) {
|
||
return weekOfYear(this, dow, doy).year
|
||
} else {
|
||
weeksTarget = weeksInYear(input, dow, doy);
|
||
if (week > weeksTarget) {
|
||
week = weeksTarget
|
||
}
|
||
return setWeekAll.call(this, input, week, weekday, dow, doy)
|
||
}
|
||
}
|
||
function setWeekAll(weekYear, week, weekday, dow, doy) {
|
||
var dayOfYearData = dayOfYearFromWeeks(weekYear, week, weekday, dow, doy), date = createUTCDate(dayOfYearData.year, 0, dayOfYearData.dayOfYear);
|
||
this.year(date.getUTCFullYear());
|
||
this.month(date.getUTCMonth());
|
||
this.date(date.getUTCDate());
|
||
return this
|
||
}
|
||
// FORMATTING
|
||
addFormatToken('Q', 0, 'Qo', 'quarter');
|
||
// ALIASES
|
||
addUnitAlias('quarter', 'Q');
|
||
// PARSING
|
||
addRegexToken('Q', match1);
|
||
addParseToken('Q', function (input, array) {
|
||
array[MONTH] = (toInt(input) - 1) * 3
|
||
});
|
||
// MOMENTS
|
||
function getSetQuarter(input) {
|
||
return input == null ? Math.ceil((this.month() + 1) / 3) : this.month((input - 1) * 3 + this.month() % 3)
|
||
}
|
||
// FORMATTING
|
||
addFormatToken('w', [
|
||
'ww',
|
||
2
|
||
], 'wo', 'week');
|
||
addFormatToken('W', [
|
||
'WW',
|
||
2
|
||
], 'Wo', 'isoWeek');
|
||
// ALIASES
|
||
addUnitAlias('week', 'w');
|
||
addUnitAlias('isoWeek', 'W');
|
||
// PARSING
|
||
addRegexToken('w', match1to2);
|
||
addRegexToken('ww', match1to2, match2);
|
||
addRegexToken('W', match1to2);
|
||
addRegexToken('WW', match1to2, match2);
|
||
addWeekParseToken([
|
||
'w',
|
||
'ww',
|
||
'W',
|
||
'WW'
|
||
], function (input, week, config, token) {
|
||
week[token.substr(0, 1)] = toInt(input)
|
||
});
|
||
// HELPERS
|
||
// LOCALES
|
||
function localeWeek(mom) {
|
||
return weekOfYear(mom, this._week.dow, this._week.doy).week
|
||
}
|
||
var defaultLocaleWeek = {
|
||
dow: 0,
|
||
// Sunday is the first day of the week.
|
||
doy: 6 // The week that contains Jan 1st is the first week of the year.
|
||
};
|
||
function localeFirstDayOfWeek() {
|
||
return this._week.dow
|
||
}
|
||
function localeFirstDayOfYear() {
|
||
return this._week.doy
|
||
}
|
||
// MOMENTS
|
||
function getSetWeek(input) {
|
||
var week = this.localeData().week(this);
|
||
return input == null ? week : this.add((input - week) * 7, 'd')
|
||
}
|
||
function getSetISOWeek(input) {
|
||
var week = weekOfYear(this, 1, 4).week;
|
||
return input == null ? week : this.add((input - week) * 7, 'd')
|
||
}
|
||
// FORMATTING
|
||
addFormatToken('D', [
|
||
'DD',
|
||
2
|
||
], 'Do', 'date');
|
||
// ALIASES
|
||
addUnitAlias('date', 'D');
|
||
// PARSING
|
||
addRegexToken('D', match1to2);
|
||
addRegexToken('DD', match1to2, match2);
|
||
addRegexToken('Do', function (isStrict, locale) {
|
||
return isStrict ? locale._ordinalParse : locale._ordinalParseLenient
|
||
});
|
||
addParseToken([
|
||
'D',
|
||
'DD'
|
||
], DATE);
|
||
addParseToken('Do', function (input, array) {
|
||
array[DATE] = toInt(input.match(match1to2)[0], 10)
|
||
});
|
||
// MOMENTS
|
||
var getSetDayOfMonth = makeGetSet('Date', true);
|
||
// FORMATTING
|
||
addFormatToken('d', 0, 'do', 'day');
|
||
addFormatToken('dd', 0, 0, function (format) {
|
||
return this.localeData().weekdaysMin(this, format)
|
||
});
|
||
addFormatToken('ddd', 0, 0, function (format) {
|
||
return this.localeData().weekdaysShort(this, format)
|
||
});
|
||
addFormatToken('dddd', 0, 0, function (format) {
|
||
return this.localeData().weekdays(this, format)
|
||
});
|
||
addFormatToken('e', 0, 0, 'weekday');
|
||
addFormatToken('E', 0, 0, 'isoWeekday');
|
||
// ALIASES
|
||
addUnitAlias('day', 'd');
|
||
addUnitAlias('weekday', 'e');
|
||
addUnitAlias('isoWeekday', 'E');
|
||
// PARSING
|
||
addRegexToken('d', match1to2);
|
||
addRegexToken('e', match1to2);
|
||
addRegexToken('E', match1to2);
|
||
addRegexToken('dd', matchWord);
|
||
addRegexToken('ddd', matchWord);
|
||
addRegexToken('dddd', matchWord);
|
||
addWeekParseToken([
|
||
'dd',
|
||
'ddd',
|
||
'dddd'
|
||
], function (input, week, config, token) {
|
||
var weekday = config._locale.weekdaysParse(input, token, config._strict);
|
||
// if we didn't get a weekday name, mark the date as invalid
|
||
if (weekday != null) {
|
||
week.d = weekday
|
||
} else {
|
||
getParsingFlags(config).invalidWeekday = input
|
||
}
|
||
});
|
||
addWeekParseToken([
|
||
'd',
|
||
'e',
|
||
'E'
|
||
], function (input, week, config, token) {
|
||
week[token] = toInt(input)
|
||
});
|
||
// HELPERS
|
||
function parseWeekday(input, locale) {
|
||
if (typeof input !== 'string') {
|
||
return input
|
||
}
|
||
if (!isNaN(input)) {
|
||
return parseInt(input, 10)
|
||
}
|
||
input = locale.weekdaysParse(input);
|
||
if (typeof input === 'number') {
|
||
return input
|
||
}
|
||
return null
|
||
}
|
||
// LOCALES
|
||
var defaultLocaleWeekdays = 'Sunday_Monday_Tuesday_Wednesday_Thursday_Friday_Saturday'.split('_');
|
||
function localeWeekdays(m, format) {
|
||
return isArray(this._weekdays) ? this._weekdays[m.day()] : this._weekdays[this._weekdays.isFormat.test(format) ? 'format' : 'standalone'][m.day()]
|
||
}
|
||
var defaultLocaleWeekdaysShort = 'Sun_Mon_Tue_Wed_Thu_Fri_Sat'.split('_');
|
||
function localeWeekdaysShort(m) {
|
||
return this._weekdaysShort[m.day()]
|
||
}
|
||
var defaultLocaleWeekdaysMin = 'Su_Mo_Tu_We_Th_Fr_Sa'.split('_');
|
||
function localeWeekdaysMin(m) {
|
||
return this._weekdaysMin[m.day()]
|
||
}
|
||
function localeWeekdaysParse(weekdayName, format, strict) {
|
||
var i, mom, regex;
|
||
if (!this._weekdaysParse) {
|
||
this._weekdaysParse = [];
|
||
this._minWeekdaysParse = [];
|
||
this._shortWeekdaysParse = [];
|
||
this._fullWeekdaysParse = []
|
||
}
|
||
for (i = 0; i < 7; i++) {
|
||
// make the regex if we don't have it already
|
||
mom = local__createLocal([
|
||
2000,
|
||
1
|
||
]).day(i);
|
||
if (strict && !this._fullWeekdaysParse[i]) {
|
||
this._fullWeekdaysParse[i] = new RegExp('^' + this.weekdays(mom, '').replace('.', '.?') + '$', 'i');
|
||
this._shortWeekdaysParse[i] = new RegExp('^' + this.weekdaysShort(mom, '').replace('.', '.?') + '$', 'i');
|
||
this._minWeekdaysParse[i] = new RegExp('^' + this.weekdaysMin(mom, '').replace('.', '.?') + '$', 'i')
|
||
}
|
||
if (!this._weekdaysParse[i]) {
|
||
regex = '^' + this.weekdays(mom, '') + '|^' + this.weekdaysShort(mom, '') + '|^' + this.weekdaysMin(mom, '');
|
||
this._weekdaysParse[i] = new RegExp(regex.replace('.', ''), 'i')
|
||
}
|
||
// test the regex
|
||
if (strict && format === 'dddd' && this._fullWeekdaysParse[i].test(weekdayName)) {
|
||
return i
|
||
} else if (strict && format === 'ddd' && this._shortWeekdaysParse[i].test(weekdayName)) {
|
||
return i
|
||
} else if (strict && format === 'dd' && this._minWeekdaysParse[i].test(weekdayName)) {
|
||
return i
|
||
} else if (!strict && this._weekdaysParse[i].test(weekdayName)) {
|
||
return i
|
||
}
|
||
}
|
||
}
|
||
// MOMENTS
|
||
function getSetDayOfWeek(input) {
|
||
if (!this.isValid()) {
|
||
return input != null ? this : NaN
|
||
}
|
||
var day = this._isUTC ? this._d.getUTCDay() : this._d.getDay();
|
||
if (input != null) {
|
||
input = parseWeekday(input, this.localeData());
|
||
return this.add(input - day, 'd')
|
||
} else {
|
||
return day
|
||
}
|
||
}
|
||
function getSetLocaleDayOfWeek(input) {
|
||
if (!this.isValid()) {
|
||
return input != null ? this : NaN
|
||
}
|
||
var weekday = (this.day() + 7 - this.localeData()._week.dow) % 7;
|
||
return input == null ? weekday : this.add(input - weekday, 'd')
|
||
}
|
||
function getSetISODayOfWeek(input) {
|
||
if (!this.isValid()) {
|
||
return input != null ? this : NaN
|
||
}
|
||
// behaves the same as moment#day except
|
||
// as a getter, returns 7 instead of 0 (1-7 range instead of 0-6)
|
||
// as a setter, sunday should belong to the previous week.
|
||
return input == null ? this.day() || 7 : this.day(this.day() % 7 ? input : input - 7)
|
||
}
|
||
// FORMATTING
|
||
addFormatToken('DDD', [
|
||
'DDDD',
|
||
3
|
||
], 'DDDo', 'dayOfYear');
|
||
// ALIASES
|
||
addUnitAlias('dayOfYear', 'DDD');
|
||
// PARSING
|
||
addRegexToken('DDD', match1to3);
|
||
addRegexToken('DDDD', match3);
|
||
addParseToken([
|
||
'DDD',
|
||
'DDDD'
|
||
], function (input, array, config) {
|
||
config._dayOfYear = toInt(input)
|
||
});
|
||
// HELPERS
|
||
// MOMENTS
|
||
function getSetDayOfYear(input) {
|
||
var dayOfYear = Math.round((this.clone().startOf('day') - this.clone().startOf('year')) / 86400000) + 1;
|
||
return input == null ? dayOfYear : this.add(input - dayOfYear, 'd')
|
||
}
|
||
// FORMATTING
|
||
function hFormat() {
|
||
return this.hours() % 12 || 12
|
||
}
|
||
addFormatToken('H', [
|
||
'HH',
|
||
2
|
||
], 0, 'hour');
|
||
addFormatToken('h', [
|
||
'hh',
|
||
2
|
||
], 0, hFormat);
|
||
addFormatToken('hmm', 0, 0, function () {
|
||
return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2)
|
||
});
|
||
addFormatToken('hmmss', 0, 0, function () {
|
||
return '' + hFormat.apply(this) + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2)
|
||
});
|
||
addFormatToken('Hmm', 0, 0, function () {
|
||
return '' + this.hours() + zeroFill(this.minutes(), 2)
|
||
});
|
||
addFormatToken('Hmmss', 0, 0, function () {
|
||
return '' + this.hours() + zeroFill(this.minutes(), 2) + zeroFill(this.seconds(), 2)
|
||
});
|
||
function meridiem(token, lowercase) {
|
||
addFormatToken(token, 0, 0, function () {
|
||
return this.localeData().meridiem(this.hours(), this.minutes(), lowercase)
|
||
})
|
||
}
|
||
meridiem('a', true);
|
||
meridiem('A', false);
|
||
// ALIASES
|
||
addUnitAlias('hour', 'h');
|
||
// PARSING
|
||
function matchMeridiem(isStrict, locale) {
|
||
return locale._meridiemParse
|
||
}
|
||
addRegexToken('a', matchMeridiem);
|
||
addRegexToken('A', matchMeridiem);
|
||
addRegexToken('H', match1to2);
|
||
addRegexToken('h', match1to2);
|
||
addRegexToken('HH', match1to2, match2);
|
||
addRegexToken('hh', match1to2, match2);
|
||
addRegexToken('hmm', match3to4);
|
||
addRegexToken('hmmss', match5to6);
|
||
addRegexToken('Hmm', match3to4);
|
||
addRegexToken('Hmmss', match5to6);
|
||
addParseToken([
|
||
'H',
|
||
'HH'
|
||
], HOUR);
|
||
addParseToken([
|
||
'a',
|
||
'A'
|
||
], function (input, array, config) {
|
||
config._isPm = config._locale.isPM(input);
|
||
config._meridiem = input
|
||
});
|
||
addParseToken([
|
||
'h',
|
||
'hh'
|
||
], function (input, array, config) {
|
||
array[HOUR] = toInt(input);
|
||
getParsingFlags(config).bigHour = true
|
||
});
|
||
addParseToken('hmm', function (input, array, config) {
|
||
var pos = input.length - 2;
|
||
array[HOUR] = toInt(input.substr(0, pos));
|
||
array[MINUTE] = toInt(input.substr(pos));
|
||
getParsingFlags(config).bigHour = true
|
||
});
|
||
addParseToken('hmmss', function (input, array, config) {
|
||
var pos1 = input.length - 4;
|
||
var pos2 = input.length - 2;
|
||
array[HOUR] = toInt(input.substr(0, pos1));
|
||
array[MINUTE] = toInt(input.substr(pos1, 2));
|
||
array[SECOND] = toInt(input.substr(pos2));
|
||
getParsingFlags(config).bigHour = true
|
||
});
|
||
addParseToken('Hmm', function (input, array, config) {
|
||
var pos = input.length - 2;
|
||
array[HOUR] = toInt(input.substr(0, pos));
|
||
array[MINUTE] = toInt(input.substr(pos))
|
||
});
|
||
addParseToken('Hmmss', function (input, array, config) {
|
||
var pos1 = input.length - 4;
|
||
var pos2 = input.length - 2;
|
||
array[HOUR] = toInt(input.substr(0, pos1));
|
||
array[MINUTE] = toInt(input.substr(pos1, 2));
|
||
array[SECOND] = toInt(input.substr(pos2))
|
||
});
|
||
// LOCALES
|
||
function localeIsPM(input) {
|
||
// IE8 Quirks Mode & IE7 Standards Mode do not allow accessing strings like arrays
|
||
// Using charAt should be more compatible.
|
||
return (input + '').toLowerCase().charAt(0) === 'p'
|
||
}
|
||
var defaultLocaleMeridiemParse = /[ap]\.?m?\.?/i;
|
||
function localeMeridiem(hours, minutes, isLower) {
|
||
if (hours > 11) {
|
||
return isLower ? 'pm' : 'PM'
|
||
} else {
|
||
return isLower ? 'am' : 'AM'
|
||
}
|
||
}
|
||
// MOMENTS
|
||
// Setting the hour should keep the time, because the user explicitly
|
||
// specified which hour he wants. So trying to maintain the same hour (in
|
||
// a new timezone) makes sense. Adding/subtracting hours does not follow
|
||
// this rule.
|
||
var getSetHour = makeGetSet('Hours', true);
|
||
// FORMATTING
|
||
addFormatToken('m', [
|
||
'mm',
|
||
2
|
||
], 0, 'minute');
|
||
// ALIASES
|
||
addUnitAlias('minute', 'm');
|
||
// PARSING
|
||
addRegexToken('m', match1to2);
|
||
addRegexToken('mm', match1to2, match2);
|
||
addParseToken([
|
||
'm',
|
||
'mm'
|
||
], MINUTE);
|
||
// MOMENTS
|
||
var getSetMinute = makeGetSet('Minutes', false);
|
||
// FORMATTING
|
||
addFormatToken('s', [
|
||
'ss',
|
||
2
|
||
], 0, 'second');
|
||
// ALIASES
|
||
addUnitAlias('second', 's');
|
||
// PARSING
|
||
addRegexToken('s', match1to2);
|
||
addRegexToken('ss', match1to2, match2);
|
||
addParseToken([
|
||
's',
|
||
'ss'
|
||
], SECOND);
|
||
// MOMENTS
|
||
var getSetSecond = makeGetSet('Seconds', false);
|
||
// FORMATTING
|
||
addFormatToken('S', 0, 0, function () {
|
||
return ~~(this.millisecond() / 100)
|
||
});
|
||
addFormatToken(0, [
|
||
'SS',
|
||
2
|
||
], 0, function () {
|
||
return ~~(this.millisecond() / 10)
|
||
});
|
||
addFormatToken(0, [
|
||
'SSS',
|
||
3
|
||
], 0, 'millisecond');
|
||
addFormatToken(0, [
|
||
'SSSS',
|
||
4
|
||
], 0, function () {
|
||
return this.millisecond() * 10
|
||
});
|
||
addFormatToken(0, [
|
||
'SSSSS',
|
||
5
|
||
], 0, function () {
|
||
return this.millisecond() * 100
|
||
});
|
||
addFormatToken(0, [
|
||
'SSSSSS',
|
||
6
|
||
], 0, function () {
|
||
return this.millisecond() * 1000
|
||
});
|
||
addFormatToken(0, [
|
||
'SSSSSSS',
|
||
7
|
||
], 0, function () {
|
||
return this.millisecond() * 10000
|
||
});
|
||
addFormatToken(0, [
|
||
'SSSSSSSS',
|
||
8
|
||
], 0, function () {
|
||
return this.millisecond() * 100000
|
||
});
|
||
addFormatToken(0, [
|
||
'SSSSSSSSS',
|
||
9
|
||
], 0, function () {
|
||
return this.millisecond() * 1000000
|
||
});
|
||
// ALIASES
|
||
addUnitAlias('millisecond', 'ms');
|
||
// PARSING
|
||
addRegexToken('S', match1to3, match1);
|
||
addRegexToken('SS', match1to3, match2);
|
||
addRegexToken('SSS', match1to3, match3);
|
||
var token;
|
||
for (token = 'SSSS'; token.length <= 9; token += 'S') {
|
||
addRegexToken(token, matchUnsigned)
|
||
}
|
||
function parseMs(input, array) {
|
||
array[MILLISECOND] = toInt(('0.' + input) * 1000)
|
||
}
|
||
for (token = 'S'; token.length <= 9; token += 'S') {
|
||
addParseToken(token, parseMs)
|
||
}
|
||
// MOMENTS
|
||
var getSetMillisecond = makeGetSet('Milliseconds', false);
|
||
// FORMATTING
|
||
addFormatToken('z', 0, 0, 'zoneAbbr');
|
||
addFormatToken('zz', 0, 0, 'zoneName');
|
||
// MOMENTS
|
||
function getZoneAbbr() {
|
||
return this._isUTC ? 'UTC' : ''
|
||
}
|
||
function getZoneName() {
|
||
return this._isUTC ? 'Coordinated Universal Time' : ''
|
||
}
|
||
var momentPrototype__proto = Moment.prototype;
|
||
momentPrototype__proto.add = add_subtract__add;
|
||
momentPrototype__proto.calendar = moment_calendar__calendar;
|
||
momentPrototype__proto.clone = clone;
|
||
momentPrototype__proto.diff = diff;
|
||
momentPrototype__proto.endOf = endOf;
|
||
momentPrototype__proto.format = format;
|
||
momentPrototype__proto.from = from;
|
||
momentPrototype__proto.fromNow = fromNow;
|
||
momentPrototype__proto.to = to;
|
||
momentPrototype__proto.toNow = toNow;
|
||
momentPrototype__proto.get = getSet;
|
||
momentPrototype__proto.invalidAt = invalidAt;
|
||
momentPrototype__proto.isAfter = isAfter;
|
||
momentPrototype__proto.isBefore = isBefore;
|
||
momentPrototype__proto.isBetween = isBetween;
|
||
momentPrototype__proto.isSame = isSame;
|
||
momentPrototype__proto.isSameOrAfter = isSameOrAfter;
|
||
momentPrototype__proto.isSameOrBefore = isSameOrBefore;
|
||
momentPrototype__proto.isValid = moment_valid__isValid;
|
||
momentPrototype__proto.lang = lang;
|
||
momentPrototype__proto.locale = locale;
|
||
momentPrototype__proto.localeData = localeData;
|
||
momentPrototype__proto.max = prototypeMax;
|
||
momentPrototype__proto.min = prototypeMin;
|
||
momentPrototype__proto.parsingFlags = parsingFlags;
|
||
momentPrototype__proto.set = getSet;
|
||
momentPrototype__proto.startOf = startOf;
|
||
momentPrototype__proto.subtract = add_subtract__subtract;
|
||
momentPrototype__proto.toArray = toArray;
|
||
momentPrototype__proto.toObject = toObject;
|
||
momentPrototype__proto.toDate = toDate;
|
||
momentPrototype__proto.toISOString = moment_format__toISOString;
|
||
momentPrototype__proto.toJSON = toJSON;
|
||
momentPrototype__proto.toString = toString;
|
||
momentPrototype__proto.unix = unix;
|
||
momentPrototype__proto.valueOf = to_type__valueOf;
|
||
momentPrototype__proto.creationData = creationData;
|
||
// Year
|
||
momentPrototype__proto.year = getSetYear;
|
||
momentPrototype__proto.isLeapYear = getIsLeapYear;
|
||
// Week Year
|
||
momentPrototype__proto.weekYear = getSetWeekYear;
|
||
momentPrototype__proto.isoWeekYear = getSetISOWeekYear;
|
||
// Quarter
|
||
momentPrototype__proto.quarter = momentPrototype__proto.quarters = getSetQuarter;
|
||
// Month
|
||
momentPrototype__proto.month = getSetMonth;
|
||
momentPrototype__proto.daysInMonth = getDaysInMonth;
|
||
// Week
|
||
momentPrototype__proto.week = momentPrototype__proto.weeks = getSetWeek;
|
||
momentPrototype__proto.isoWeek = momentPrototype__proto.isoWeeks = getSetISOWeek;
|
||
momentPrototype__proto.weeksInYear = getWeeksInYear;
|
||
momentPrototype__proto.isoWeeksInYear = getISOWeeksInYear;
|
||
// Day
|
||
momentPrototype__proto.date = getSetDayOfMonth;
|
||
momentPrototype__proto.day = momentPrototype__proto.days = getSetDayOfWeek;
|
||
momentPrototype__proto.weekday = getSetLocaleDayOfWeek;
|
||
momentPrototype__proto.isoWeekday = getSetISODayOfWeek;
|
||
momentPrototype__proto.dayOfYear = getSetDayOfYear;
|
||
// Hour
|
||
momentPrototype__proto.hour = momentPrototype__proto.hours = getSetHour;
|
||
// Minute
|
||
momentPrototype__proto.minute = momentPrototype__proto.minutes = getSetMinute;
|
||
// Second
|
||
momentPrototype__proto.second = momentPrototype__proto.seconds = getSetSecond;
|
||
// Millisecond
|
||
momentPrototype__proto.millisecond = momentPrototype__proto.milliseconds = getSetMillisecond;
|
||
// Offset
|
||
momentPrototype__proto.utcOffset = getSetOffset;
|
||
momentPrototype__proto.utc = setOffsetToUTC;
|
||
momentPrototype__proto.local = setOffsetToLocal;
|
||
momentPrototype__proto.parseZone = setOffsetToParsedOffset;
|
||
momentPrototype__proto.hasAlignedHourOffset = hasAlignedHourOffset;
|
||
momentPrototype__proto.isDST = isDaylightSavingTime;
|
||
momentPrototype__proto.isDSTShifted = isDaylightSavingTimeShifted;
|
||
momentPrototype__proto.isLocal = isLocal;
|
||
momentPrototype__proto.isUtcOffset = isUtcOffset;
|
||
momentPrototype__proto.isUtc = isUtc;
|
||
momentPrototype__proto.isUTC = isUtc;
|
||
// Timezone
|
||
momentPrototype__proto.zoneAbbr = getZoneAbbr;
|
||
momentPrototype__proto.zoneName = getZoneName;
|
||
// Deprecations
|
||
momentPrototype__proto.dates = deprecate('dates accessor is deprecated. Use date instead.', getSetDayOfMonth);
|
||
momentPrototype__proto.months = deprecate('months accessor is deprecated. Use month instead', getSetMonth);
|
||
momentPrototype__proto.years = deprecate('years accessor is deprecated. Use year instead', getSetYear);
|
||
momentPrototype__proto.zone = deprecate('moment().zone is deprecated, use moment().utcOffset instead. https://github.com/moment/moment/issues/1779', getSetZone);
|
||
var momentPrototype = momentPrototype__proto;
|
||
function moment__createUnix(input) {
|
||
return local__createLocal(input * 1000)
|
||
}
|
||
function moment__createInZone() {
|
||
return local__createLocal.apply(null, arguments).parseZone()
|
||
}
|
||
var defaultCalendar = {
|
||
sameDay: '[Today at] LT',
|
||
nextDay: '[Tomorrow at] LT',
|
||
nextWeek: 'dddd [at] LT',
|
||
lastDay: '[Yesterday at] LT',
|
||
lastWeek: '[Last] dddd [at] LT',
|
||
sameElse: 'L'
|
||
};
|
||
function locale_calendar__calendar(key, mom, now) {
|
||
var output = this._calendar[key];
|
||
return isFunction(output) ? output.call(mom, now) : output
|
||
}
|
||
var defaultLongDateFormat = {
|
||
LTS: 'h:mm:ss A',
|
||
LT: 'h:mm A',
|
||
L: 'MM/DD/YYYY',
|
||
LL: 'MMMM D, YYYY',
|
||
LLL: 'MMMM D, YYYY h:mm A',
|
||
LLLL: 'dddd, MMMM D, YYYY h:mm A'
|
||
};
|
||
function longDateFormat(key) {
|
||
var format = this._longDateFormat[key], formatUpper = this._longDateFormat[key.toUpperCase()];
|
||
if (format || !formatUpper) {
|
||
return format
|
||
}
|
||
this._longDateFormat[key] = formatUpper.replace(/MMMM|MM|DD|dddd/g, function (val) {
|
||
return val.slice(1)
|
||
});
|
||
return this._longDateFormat[key]
|
||
}
|
||
var defaultInvalidDate = 'Invalid date';
|
||
function invalidDate() {
|
||
return this._invalidDate
|
||
}
|
||
var defaultOrdinal = '%d';
|
||
var defaultOrdinalParse = /\d{1,2}/;
|
||
function ordinal(number) {
|
||
return this._ordinal.replace('%d', number)
|
||
}
|
||
function preParsePostFormat(string) {
|
||
return string
|
||
}
|
||
var defaultRelativeTime = {
|
||
future: 'in %s',
|
||
past: '%s ago',
|
||
s: 'a few seconds',
|
||
m: 'a minute',
|
||
mm: '%d minutes',
|
||
h: 'an hour',
|
||
hh: '%d hours',
|
||
d: 'a day',
|
||
dd: '%d days',
|
||
M: 'a month',
|
||
MM: '%d months',
|
||
y: 'a year',
|
||
yy: '%d years'
|
||
};
|
||
function relative__relativeTime(number, withoutSuffix, string, isFuture) {
|
||
var output = this._relativeTime[string];
|
||
return isFunction(output) ? output(number, withoutSuffix, string, isFuture) : output.replace(/%d/i, number)
|
||
}
|
||
function pastFuture(diff, output) {
|
||
var format = this._relativeTime[diff > 0 ? 'future' : 'past'];
|
||
return isFunction(format) ? format(output) : format.replace(/%s/i, output)
|
||
}
|
||
var prototype__proto = Locale.prototype;
|
||
prototype__proto._calendar = defaultCalendar;
|
||
prototype__proto.calendar = locale_calendar__calendar;
|
||
prototype__proto._longDateFormat = defaultLongDateFormat;
|
||
prototype__proto.longDateFormat = longDateFormat;
|
||
prototype__proto._invalidDate = defaultInvalidDate;
|
||
prototype__proto.invalidDate = invalidDate;
|
||
prototype__proto._ordinal = defaultOrdinal;
|
||
prototype__proto.ordinal = ordinal;
|
||
prototype__proto._ordinalParse = defaultOrdinalParse;
|
||
prototype__proto.preparse = preParsePostFormat;
|
||
prototype__proto.postformat = preParsePostFormat;
|
||
prototype__proto._relativeTime = defaultRelativeTime;
|
||
prototype__proto.relativeTime = relative__relativeTime;
|
||
prototype__proto.pastFuture = pastFuture;
|
||
prototype__proto.set = locale_set__set;
|
||
// Month
|
||
prototype__proto.months = localeMonths;
|
||
prototype__proto._months = defaultLocaleMonths;
|
||
prototype__proto.monthsShort = localeMonthsShort;
|
||
prototype__proto._monthsShort = defaultLocaleMonthsShort;
|
||
prototype__proto.monthsParse = localeMonthsParse;
|
||
prototype__proto._monthsRegex = defaultMonthsRegex;
|
||
prototype__proto.monthsRegex = monthsRegex;
|
||
prototype__proto._monthsShortRegex = defaultMonthsShortRegex;
|
||
prototype__proto.monthsShortRegex = monthsShortRegex;
|
||
// Week
|
||
prototype__proto.week = localeWeek;
|
||
prototype__proto._week = defaultLocaleWeek;
|
||
prototype__proto.firstDayOfYear = localeFirstDayOfYear;
|
||
prototype__proto.firstDayOfWeek = localeFirstDayOfWeek;
|
||
// Day of Week
|
||
prototype__proto.weekdays = localeWeekdays;
|
||
prototype__proto._weekdays = defaultLocaleWeekdays;
|
||
prototype__proto.weekdaysMin = localeWeekdaysMin;
|
||
prototype__proto._weekdaysMin = defaultLocaleWeekdaysMin;
|
||
prototype__proto.weekdaysShort = localeWeekdaysShort;
|
||
prototype__proto._weekdaysShort = defaultLocaleWeekdaysShort;
|
||
prototype__proto.weekdaysParse = localeWeekdaysParse;
|
||
// Hours
|
||
prototype__proto.isPM = localeIsPM;
|
||
prototype__proto._meridiemParse = defaultLocaleMeridiemParse;
|
||
prototype__proto.meridiem = localeMeridiem;
|
||
function lists__get(format, index, field, setter) {
|
||
var locale = locale_locales__getLocale();
|
||
var utc = create_utc__createUTC().set(setter, index);
|
||
return locale[field](utc, format)
|
||
}
|
||
function list(format, index, field, count, setter) {
|
||
if (typeof format === 'number') {
|
||
index = format;
|
||
format = undefined
|
||
}
|
||
format = format || '';
|
||
if (index != null) {
|
||
return lists__get(format, index, field, setter)
|
||
}
|
||
var i;
|
||
var out = [];
|
||
for (i = 0; i < count; i++) {
|
||
out[i] = lists__get(format, i, field, setter)
|
||
}
|
||
return out
|
||
}
|
||
function lists__listMonths(format, index) {
|
||
return list(format, index, 'months', 12, 'month')
|
||
}
|
||
function lists__listMonthsShort(format, index) {
|
||
return list(format, index, 'monthsShort', 12, 'month')
|
||
}
|
||
function lists__listWeekdays(format, index) {
|
||
return list(format, index, 'weekdays', 7, 'day')
|
||
}
|
||
function lists__listWeekdaysShort(format, index) {
|
||
return list(format, index, 'weekdaysShort', 7, 'day')
|
||
}
|
||
function lists__listWeekdaysMin(format, index) {
|
||
return list(format, index, 'weekdaysMin', 7, 'day')
|
||
}
|
||
locale_locales__getSetGlobalLocale('en', {
|
||
ordinalParse: /\d{1,2}(th|st|nd|rd)/,
|
||
ordinal: function (number) {
|
||
var b = number % 10, output = toInt(number % 100 / 10) === 1 ? 'th' : b === 1 ? 'st' : b === 2 ? 'nd' : b === 3 ? 'rd' : 'th';
|
||
return number + output
|
||
}
|
||
});
|
||
// Side effect imports
|
||
utils_hooks__hooks.lang = deprecate('moment.lang is deprecated. Use moment.locale instead.', locale_locales__getSetGlobalLocale);
|
||
utils_hooks__hooks.langData = deprecate('moment.langData is deprecated. Use moment.localeData instead.', locale_locales__getLocale);
|
||
var mathAbs = Math.abs;
|
||
function duration_abs__abs() {
|
||
var data = this._data;
|
||
this._milliseconds = mathAbs(this._milliseconds);
|
||
this._days = mathAbs(this._days);
|
||
this._months = mathAbs(this._months);
|
||
data.milliseconds = mathAbs(data.milliseconds);
|
||
data.seconds = mathAbs(data.seconds);
|
||
data.minutes = mathAbs(data.minutes);
|
||
data.hours = mathAbs(data.hours);
|
||
data.months = mathAbs(data.months);
|
||
data.years = mathAbs(data.years);
|
||
return this
|
||
}
|
||
function duration_add_subtract__addSubtract(duration, input, value, direction) {
|
||
var other = create__createDuration(input, value);
|
||
duration._milliseconds += direction * other._milliseconds;
|
||
duration._days += direction * other._days;
|
||
duration._months += direction * other._months;
|
||
return duration._bubble()
|
||
}
|
||
// supports only 2.0-style add(1, 's') or add(duration)
|
||
function duration_add_subtract__add(input, value) {
|
||
return duration_add_subtract__addSubtract(this, input, value, 1)
|
||
}
|
||
// supports only 2.0-style subtract(1, 's') or subtract(duration)
|
||
function duration_add_subtract__subtract(input, value) {
|
||
return duration_add_subtract__addSubtract(this, input, value, -1)
|
||
}
|
||
function absCeil(number) {
|
||
if (number < 0) {
|
||
return Math.floor(number)
|
||
} else {
|
||
return Math.ceil(number)
|
||
}
|
||
}
|
||
function bubble() {
|
||
var milliseconds = this._milliseconds;
|
||
var days = this._days;
|
||
var months = this._months;
|
||
var data = this._data;
|
||
var seconds, minutes, hours, years, monthsFromDays;
|
||
// if we have a mix of positive and negative values, bubble down first
|
||
// check: https://github.com/moment/moment/issues/2166
|
||
if (!(milliseconds >= 0 && days >= 0 && months >= 0 || milliseconds <= 0 && days <= 0 && months <= 0)) {
|
||
milliseconds += absCeil(monthsToDays(months) + days) * 86400000;
|
||
days = 0;
|
||
months = 0
|
||
}
|
||
// The following code bubbles up values, see the tests for
|
||
// examples of what that means.
|
||
data.milliseconds = milliseconds % 1000;
|
||
seconds = absFloor(milliseconds / 1000);
|
||
data.seconds = seconds % 60;
|
||
minutes = absFloor(seconds / 60);
|
||
data.minutes = minutes % 60;
|
||
hours = absFloor(minutes / 60);
|
||
data.hours = hours % 24;
|
||
days += absFloor(hours / 24);
|
||
// convert days to months
|
||
monthsFromDays = absFloor(daysToMonths(days));
|
||
months += monthsFromDays;
|
||
days -= absCeil(monthsToDays(monthsFromDays));
|
||
// 12 months -> 1 year
|
||
years = absFloor(months / 12);
|
||
months %= 12;
|
||
data.days = days;
|
||
data.months = months;
|
||
data.years = years;
|
||
return this
|
||
}
|
||
function daysToMonths(days) {
|
||
// 400 years have 146097 days (taking into account leap year rules)
|
||
// 400 years have 12 months === 4800
|
||
return days * 4800 / 146097
|
||
}
|
||
function monthsToDays(months) {
|
||
// the reverse of daysToMonths
|
||
return months * 146097 / 4800
|
||
}
|
||
function as(units) {
|
||
var days;
|
||
var months;
|
||
var milliseconds = this._milliseconds;
|
||
units = normalizeUnits(units);
|
||
if (units === 'month' || units === 'year') {
|
||
days = this._days + milliseconds / 86400000;
|
||
months = this._months + daysToMonths(days);
|
||
return units === 'month' ? months : months / 12
|
||
} else {
|
||
// handle milliseconds separately because of floating point math errors (issue #1867)
|
||
days = this._days + Math.round(monthsToDays(this._months));
|
||
switch (units) {
|
||
case 'week':
|
||
return days / 7 + milliseconds / 604800000;
|
||
case 'day':
|
||
return days + milliseconds / 86400000;
|
||
case 'hour':
|
||
return days * 24 + milliseconds / 3600000;
|
||
case 'minute':
|
||
return days * 1440 + milliseconds / 60000;
|
||
case 'second':
|
||
return days * 86400 + milliseconds / 1000;
|
||
// Math.floor prevents floating point math errors here
|
||
case 'millisecond':
|
||
return Math.floor(days * 86400000) + milliseconds;
|
||
default:
|
||
throw new Error('Unknown unit ' + units)
|
||
}
|
||
}
|
||
}
|
||
// TODO: Use this.as('ms')?
|
||
function duration_as__valueOf() {
|
||
return this._milliseconds + this._days * 86400000 + this._months % 12 * 2592000000 + toInt(this._months / 12) * 31536000000
|
||
}
|
||
function makeAs(alias) {
|
||
return function () {
|
||
return this.as(alias)
|
||
}
|
||
}
|
||
var asMilliseconds = makeAs('ms');
|
||
var asSeconds = makeAs('s');
|
||
var asMinutes = makeAs('m');
|
||
var asHours = makeAs('h');
|
||
var asDays = makeAs('d');
|
||
var asWeeks = makeAs('w');
|
||
var asMonths = makeAs('M');
|
||
var asYears = makeAs('y');
|
||
function duration_get__get(units) {
|
||
units = normalizeUnits(units);
|
||
return this[units + 's']()
|
||
}
|
||
function makeGetter(name) {
|
||
return function () {
|
||
return this._data[name]
|
||
}
|
||
}
|
||
var milliseconds = makeGetter('milliseconds');
|
||
var seconds = makeGetter('seconds');
|
||
var minutes = makeGetter('minutes');
|
||
var hours = makeGetter('hours');
|
||
var days = makeGetter('days');
|
||
var months = makeGetter('months');
|
||
var years = makeGetter('years');
|
||
function weeks() {
|
||
return absFloor(this.days() / 7)
|
||
}
|
||
var round = Math.round;
|
||
var thresholds = {
|
||
s: 45,
|
||
// seconds to minute
|
||
m: 45,
|
||
// minutes to hour
|
||
h: 22,
|
||
// hours to day
|
||
d: 26,
|
||
// days to month
|
||
M: 11 // months to year
|
||
};
|
||
// helper function for moment.fn.from, moment.fn.fromNow, and moment.duration.fn.humanize
|
||
function substituteTimeAgo(string, number, withoutSuffix, isFuture, locale) {
|
||
return locale.relativeTime(number || 1, !!withoutSuffix, string, isFuture)
|
||
}
|
||
function duration_humanize__relativeTime(posNegDuration, withoutSuffix, locale) {
|
||
var duration = create__createDuration(posNegDuration).abs();
|
||
var seconds = round(duration.as('s'));
|
||
var minutes = round(duration.as('m'));
|
||
var hours = round(duration.as('h'));
|
||
var days = round(duration.as('d'));
|
||
var months = round(duration.as('M'));
|
||
var years = round(duration.as('y'));
|
||
var a = seconds < thresholds.s && [
|
||
's',
|
||
seconds
|
||
] || minutes <= 1 && ['m'] || minutes < thresholds.m && [
|
||
'mm',
|
||
minutes
|
||
] || hours <= 1 && ['h'] || hours < thresholds.h && [
|
||
'hh',
|
||
hours
|
||
] || days <= 1 && ['d'] || days < thresholds.d && [
|
||
'dd',
|
||
days
|
||
] || months <= 1 && ['M'] || months < thresholds.M && [
|
||
'MM',
|
||
months
|
||
] || years <= 1 && ['y'] || [
|
||
'yy',
|
||
years
|
||
];
|
||
a[2] = withoutSuffix;
|
||
a[3] = +posNegDuration > 0;
|
||
a[4] = locale;
|
||
return substituteTimeAgo.apply(null, a)
|
||
}
|
||
// This function allows you to set a threshold for relative time strings
|
||
function duration_humanize__getSetRelativeTimeThreshold(threshold, limit) {
|
||
if (thresholds[threshold] === undefined) {
|
||
return false
|
||
}
|
||
if (limit === undefined) {
|
||
return thresholds[threshold]
|
||
}
|
||
thresholds[threshold] = limit;
|
||
return true
|
||
}
|
||
function humanize(withSuffix) {
|
||
var locale = this.localeData();
|
||
var output = duration_humanize__relativeTime(this, !withSuffix, locale);
|
||
if (withSuffix) {
|
||
output = locale.pastFuture(+this, output)
|
||
}
|
||
return locale.postformat(output)
|
||
}
|
||
var iso_string__abs = Math.abs;
|
||
function iso_string__toISOString() {
|
||
// for ISO strings we do not use the normal bubbling rules:
|
||
// * milliseconds bubble up until they become hours
|
||
// * days do not bubble at all
|
||
// * months bubble up until they become years
|
||
// This is because there is no context-free conversion between hours and days
|
||
// (think of clock changes)
|
||
// and also not between days and months (28-31 days per month)
|
||
var seconds = iso_string__abs(this._milliseconds) / 1000;
|
||
var days = iso_string__abs(this._days);
|
||
var months = iso_string__abs(this._months);
|
||
var minutes, hours, years;
|
||
// 3600 seconds -> 60 minutes -> 1 hour
|
||
minutes = absFloor(seconds / 60);
|
||
hours = absFloor(minutes / 60);
|
||
seconds %= 60;
|
||
minutes %= 60;
|
||
// 12 months -> 1 year
|
||
years = absFloor(months / 12);
|
||
months %= 12;
|
||
// inspired by https://github.com/dordille/moment-isoduration/blob/master/moment.isoduration.js
|
||
var Y = years;
|
||
var M = months;
|
||
var D = days;
|
||
var h = hours;
|
||
var m = minutes;
|
||
var s = seconds;
|
||
var total = this.asSeconds();
|
||
if (!total) {
|
||
// this is the same as C#'s (Noda) and python (isodate)...
|
||
// but not other JS (goog.date)
|
||
return 'P0D'
|
||
}
|
||
return (total < 0 ? '-' : '') + 'P' + (Y ? Y + 'Y' : '') + (M ? M + 'M' : '') + (D ? D + 'D' : '') + (h || m || s ? 'T' : '') + (h ? h + 'H' : '') + (m ? m + 'M' : '') + (s ? s + 'S' : '')
|
||
}
|
||
var duration_prototype__proto = Duration.prototype;
|
||
duration_prototype__proto.abs = duration_abs__abs;
|
||
duration_prototype__proto.add = duration_add_subtract__add;
|
||
duration_prototype__proto.subtract = duration_add_subtract__subtract;
|
||
duration_prototype__proto.as = as;
|
||
duration_prototype__proto.asMilliseconds = asMilliseconds;
|
||
duration_prototype__proto.asSeconds = asSeconds;
|
||
duration_prototype__proto.asMinutes = asMinutes;
|
||
duration_prototype__proto.asHours = asHours;
|
||
duration_prototype__proto.asDays = asDays;
|
||
duration_prototype__proto.asWeeks = asWeeks;
|
||
duration_prototype__proto.asMonths = asMonths;
|
||
duration_prototype__proto.asYears = asYears;
|
||
duration_prototype__proto.valueOf = duration_as__valueOf;
|
||
duration_prototype__proto._bubble = bubble;
|
||
duration_prototype__proto.get = duration_get__get;
|
||
duration_prototype__proto.milliseconds = milliseconds;
|
||
duration_prototype__proto.seconds = seconds;
|
||
duration_prototype__proto.minutes = minutes;
|
||
duration_prototype__proto.hours = hours;
|
||
duration_prototype__proto.days = days;
|
||
duration_prototype__proto.weeks = weeks;
|
||
duration_prototype__proto.months = months;
|
||
duration_prototype__proto.years = years;
|
||
duration_prototype__proto.humanize = humanize;
|
||
duration_prototype__proto.toISOString = iso_string__toISOString;
|
||
duration_prototype__proto.toString = iso_string__toISOString;
|
||
duration_prototype__proto.toJSON = iso_string__toISOString;
|
||
duration_prototype__proto.locale = locale;
|
||
duration_prototype__proto.localeData = localeData;
|
||
// Deprecations
|
||
duration_prototype__proto.toIsoString = deprecate('toIsoString() is deprecated. Please use toISOString() instead (notice the capitals)', iso_string__toISOString);
|
||
duration_prototype__proto.lang = lang;
|
||
// Side effect imports
|
||
// FORMATTING
|
||
addFormatToken('X', 0, 0, 'unix');
|
||
addFormatToken('x', 0, 0, 'valueOf');
|
||
// PARSING
|
||
addRegexToken('x', matchSigned);
|
||
addRegexToken('X', matchTimestamp);
|
||
addParseToken('X', function (input, array, config) {
|
||
config._d = new Date(parseFloat(input, 10) * 1000)
|
||
});
|
||
addParseToken('x', function (input, array, config) {
|
||
config._d = new Date(toInt(input))
|
||
});
|
||
// Side effect imports
|
||
utils_hooks__hooks.version = '2.12.0';
|
||
setHookCallback(local__createLocal);
|
||
utils_hooks__hooks.fn = momentPrototype;
|
||
utils_hooks__hooks.min = min;
|
||
utils_hooks__hooks.max = max;
|
||
utils_hooks__hooks.now = now;
|
||
utils_hooks__hooks.utc = create_utc__createUTC;
|
||
utils_hooks__hooks.unix = moment__createUnix;
|
||
utils_hooks__hooks.months = lists__listMonths;
|
||
utils_hooks__hooks.isDate = isDate;
|
||
utils_hooks__hooks.locale = locale_locales__getSetGlobalLocale;
|
||
utils_hooks__hooks.invalid = valid__createInvalid;
|
||
utils_hooks__hooks.duration = create__createDuration;
|
||
utils_hooks__hooks.isMoment = isMoment;
|
||
utils_hooks__hooks.weekdays = lists__listWeekdays;
|
||
utils_hooks__hooks.parseZone = moment__createInZone;
|
||
utils_hooks__hooks.localeData = locale_locales__getLocale;
|
||
utils_hooks__hooks.isDuration = isDuration;
|
||
utils_hooks__hooks.monthsShort = lists__listMonthsShort;
|
||
utils_hooks__hooks.weekdaysMin = lists__listWeekdaysMin;
|
||
utils_hooks__hooks.defineLocale = defineLocale;
|
||
utils_hooks__hooks.updateLocale = updateLocale;
|
||
utils_hooks__hooks.locales = locale_locales__listLocales;
|
||
utils_hooks__hooks.weekdaysShort = lists__listWeekdaysShort;
|
||
utils_hooks__hooks.normalizeUnits = normalizeUnits;
|
||
utils_hooks__hooks.relativeTimeThreshold = duration_humanize__getSetRelativeTimeThreshold;
|
||
utils_hooks__hooks.prototype = momentPrototype;
|
||
var _moment = utils_hooks__hooks;
|
||
return _moment
|
||
}))
|
||
});
|
||
// source: src/controls/static-ago.coffee
|
||
require.define('./controls/static-ago', function (module, exports, __dirname, __filename, process) {
|
||
var Control, StaticAgo, moment, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
Control = require('./controls/control');
|
||
moment = require('moment/moment');
|
||
module.exports = StaticAgo = function (superClass) {
|
||
extend(StaticAgo, superClass);
|
||
function StaticAgo() {
|
||
return StaticAgo.__super__.constructor.apply(this, arguments)
|
||
}
|
||
StaticAgo.prototype.tag = 'daisho-static-ago';
|
||
StaticAgo.prototype.html = '<div>{ ago(input.ref.get(input.name)) }</div>';
|
||
StaticAgo.prototype.init = function () {
|
||
return StaticAgo.__super__.init.apply(this, arguments)
|
||
};
|
||
StaticAgo.prototype.ago = function (date) {
|
||
return moment(date).fromNow()
|
||
};
|
||
return StaticAgo
|
||
}(Control)
|
||
});
|
||
// source: node_modules/selectize/dist/js/selectize.js
|
||
require.define('selectize/dist/js/selectize', function (module, exports, __dirname, __filename, process) {
|
||
/**
|
||
* selectize.js (v0.12.1)
|
||
* Copyright (c) 2013–2015 Brian Reavis & contributors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
|
||
* file except in compliance with the License. You may obtain a copy of the License at:
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software distributed under
|
||
* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
|
||
* ANY KIND, either express or implied. See the License for the specific language
|
||
* governing permissions and limitations under the License.
|
||
*
|
||
* @author Brian Reavis <[email protected]>
|
||
*/
|
||
/*jshint curly:false */
|
||
/*jshint browser:true */
|
||
(function (root, factory) {
|
||
if (typeof define === 'function' && define.amd) {
|
||
define([
|
||
'jquery',
|
||
'sifter',
|
||
'microplugin'
|
||
], factory)
|
||
} else if (typeof exports === 'object') {
|
||
module.exports = factory(require('jquery/dist/jquery'), require('sifter/sifter'), require('microplugin/src/microplugin'))
|
||
} else {
|
||
root.Selectize = factory(root.jQuery, root.Sifter, root.MicroPlugin)
|
||
}
|
||
}(this, function ($, Sifter, MicroPlugin) {
|
||
'use strict';
|
||
var highlight = function ($element, pattern) {
|
||
if (typeof pattern === 'string' && !pattern.length)
|
||
return;
|
||
var regex = typeof pattern === 'string' ? new RegExp(pattern, 'i') : pattern;
|
||
var highlight = function (node) {
|
||
var skip = 0;
|
||
if (node.nodeType === 3) {
|
||
var pos = node.data.search(regex);
|
||
if (pos >= 0 && node.data.length > 0) {
|
||
var match = node.data.match(regex);
|
||
var spannode = document.createElement('span');
|
||
spannode.className = 'highlight';
|
||
var middlebit = node.splitText(pos);
|
||
var endbit = middlebit.splitText(match[0].length);
|
||
var middleclone = middlebit.cloneNode(true);
|
||
spannode.appendChild(middleclone);
|
||
middlebit.parentNode.replaceChild(spannode, middlebit);
|
||
skip = 1
|
||
}
|
||
} else if (node.nodeType === 1 && node.childNodes && !/(script|style)/i.test(node.tagName)) {
|
||
for (var i = 0; i < node.childNodes.length; ++i) {
|
||
i += highlight(node.childNodes[i])
|
||
}
|
||
}
|
||
return skip
|
||
};
|
||
return $element.each(function () {
|
||
highlight(this)
|
||
})
|
||
};
|
||
var MicroEvent = function () {
|
||
};
|
||
MicroEvent.prototype = {
|
||
on: function (event, fct) {
|
||
this._events = this._events || {};
|
||
this._events[event] = this._events[event] || [];
|
||
this._events[event].push(fct)
|
||
},
|
||
off: function (event, fct) {
|
||
var n = arguments.length;
|
||
if (n === 0)
|
||
return delete this._events;
|
||
if (n === 1)
|
||
return delete this._events[event];
|
||
this._events = this._events || {};
|
||
if (event in this._events === false)
|
||
return;
|
||
this._events[event].splice(this._events[event].indexOf(fct), 1)
|
||
},
|
||
trigger: function (event) {
|
||
this._events = this._events || {};
|
||
if (event in this._events === false)
|
||
return;
|
||
for (var i = 0; i < this._events[event].length; i++) {
|
||
this._events[event][i].apply(this, Array.prototype.slice.call(arguments, 1))
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Mixin will delegate all MicroEvent.js function in the destination object.
|
||
*
|
||
* - MicroEvent.mixin(Foobar) will make Foobar able to use MicroEvent
|
||
*
|
||
* @param {object} the object which will support MicroEvent
|
||
*/
|
||
MicroEvent.mixin = function (destObject) {
|
||
var props = [
|
||
'on',
|
||
'off',
|
||
'trigger'
|
||
];
|
||
for (var i = 0; i < props.length; i++) {
|
||
destObject.prototype[props[i]] = MicroEvent.prototype[props[i]]
|
||
}
|
||
};
|
||
var IS_MAC = /Mac/.test(navigator.userAgent);
|
||
var KEY_A = 65;
|
||
var KEY_COMMA = 188;
|
||
var KEY_RETURN = 13;
|
||
var KEY_ESC = 27;
|
||
var KEY_LEFT = 37;
|
||
var KEY_UP = 38;
|
||
var KEY_P = 80;
|
||
var KEY_RIGHT = 39;
|
||
var KEY_DOWN = 40;
|
||
var KEY_N = 78;
|
||
var KEY_BACKSPACE = 8;
|
||
var KEY_DELETE = 46;
|
||
var KEY_SHIFT = 16;
|
||
var KEY_CMD = IS_MAC ? 91 : 17;
|
||
var KEY_CTRL = IS_MAC ? 18 : 17;
|
||
var KEY_TAB = 9;
|
||
var TAG_SELECT = 1;
|
||
var TAG_INPUT = 2;
|
||
// for now, android support in general is too spotty to support validity
|
||
var SUPPORTS_VALIDITY_API = !/android/i.test(window.navigator.userAgent) && !!document.createElement('form').validity;
|
||
var isset = function (object) {
|
||
return typeof object !== 'undefined'
|
||
};
|
||
/**
|
||
* Converts a scalar to its best string representation
|
||
* for hash keys and HTML attribute values.
|
||
*
|
||
* Transformations:
|
||
* 'str' -> 'str'
|
||
* null -> ''
|
||
* undefined -> ''
|
||
* true -> '1'
|
||
* false -> '0'
|
||
* 0 -> '0'
|
||
* 1 -> '1'
|
||
*
|
||
* @param {string} value
|
||
* @returns {string|null}
|
||
*/
|
||
var hash_key = function (value) {
|
||
if (typeof value === 'undefined' || value === null)
|
||
return null;
|
||
if (typeof value === 'boolean')
|
||
return value ? '1' : '0';
|
||
return value + ''
|
||
};
|
||
/**
|
||
* Escapes a string for use within HTML.
|
||
*
|
||
* @param {string} str
|
||
* @returns {string}
|
||
*/
|
||
var escape_html = function (str) {
|
||
return (str + '').replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(/"/g, '"')
|
||
};
|
||
/**
|
||
* Escapes "$" characters in replacement strings.
|
||
*
|
||
* @param {string} str
|
||
* @returns {string}
|
||
*/
|
||
var escape_replace = function (str) {
|
||
return (str + '').replace(/\$/g, '$$$$')
|
||
};
|
||
var hook = {};
|
||
/**
|
||
* Wraps `method` on `self` so that `fn`
|
||
* is invoked before the original method.
|
||
*
|
||
* @param {object} self
|
||
* @param {string} method
|
||
* @param {function} fn
|
||
*/
|
||
hook.before = function (self, method, fn) {
|
||
var original = self[method];
|
||
self[method] = function () {
|
||
fn.apply(self, arguments);
|
||
return original.apply(self, arguments)
|
||
}
|
||
};
|
||
/**
|
||
* Wraps `method` on `self` so that `fn`
|
||
* is invoked after the original method.
|
||
*
|
||
* @param {object} self
|
||
* @param {string} method
|
||
* @param {function} fn
|
||
*/
|
||
hook.after = function (self, method, fn) {
|
||
var original = self[method];
|
||
self[method] = function () {
|
||
var result = original.apply(self, arguments);
|
||
fn.apply(self, arguments);
|
||
return result
|
||
}
|
||
};
|
||
/**
|
||
* Wraps `fn` so that it can only be invoked once.
|
||
*
|
||
* @param {function} fn
|
||
* @returns {function}
|
||
*/
|
||
var once = function (fn) {
|
||
var called = false;
|
||
return function () {
|
||
if (called)
|
||
return;
|
||
called = true;
|
||
fn.apply(this, arguments)
|
||
}
|
||
};
|
||
/**
|
||
* Wraps `fn` so that it can only be called once
|
||
* every `delay` milliseconds (invoked on the falling edge).
|
||
*
|
||
* @param {function} fn
|
||
* @param {int} delay
|
||
* @returns {function}
|
||
*/
|
||
var debounce = function (fn, delay) {
|
||
var timeout;
|
||
return function () {
|
||
var self = this;
|
||
var args = arguments;
|
||
window.clearTimeout(timeout);
|
||
timeout = window.setTimeout(function () {
|
||
fn.apply(self, args)
|
||
}, delay)
|
||
}
|
||
};
|
||
/**
|
||
* Debounce all fired events types listed in `types`
|
||
* while executing the provided `fn`.
|
||
*
|
||
* @param {object} self
|
||
* @param {array} types
|
||
* @param {function} fn
|
||
*/
|
||
var debounce_events = function (self, types, fn) {
|
||
var type;
|
||
var trigger = self.trigger;
|
||
var event_args = {};
|
||
// override trigger method
|
||
self.trigger = function () {
|
||
var type = arguments[0];
|
||
if (types.indexOf(type) !== -1) {
|
||
event_args[type] = arguments
|
||
} else {
|
||
return trigger.apply(self, arguments)
|
||
}
|
||
};
|
||
// invoke provided function
|
||
fn.apply(self, []);
|
||
self.trigger = trigger;
|
||
// trigger queued events
|
||
for (type in event_args) {
|
||
if (event_args.hasOwnProperty(type)) {
|
||
trigger.apply(self, event_args[type])
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* A workaround for http://bugs.jquery.com/ticket/6696
|
||
*
|
||
* @param {object} $parent - Parent element to listen on.
|
||
* @param {string} event - Event name.
|
||
* @param {string} selector - Descendant selector to filter by.
|
||
* @param {function} fn - Event handler.
|
||
*/
|
||
var watchChildEvent = function ($parent, event, selector, fn) {
|
||
$parent.on(event, selector, function (e) {
|
||
var child = e.target;
|
||
while (child && child.parentNode !== $parent[0]) {
|
||
child = child.parentNode
|
||
}
|
||
e.currentTarget = child;
|
||
return fn.apply(this, [e])
|
||
})
|
||
};
|
||
/**
|
||
* Determines the current selection within a text input control.
|
||
* Returns an object containing:
|
||
* - start
|
||
* - length
|
||
*
|
||
* @param {object} input
|
||
* @returns {object}
|
||
*/
|
||
var getSelection = function (input) {
|
||
var result = {};
|
||
if ('selectionStart' in input) {
|
||
result.start = input.selectionStart;
|
||
result.length = input.selectionEnd - result.start
|
||
} else if (document.selection) {
|
||
input.focus();
|
||
var sel = document.selection.createRange();
|
||
var selLen = document.selection.createRange().text.length;
|
||
sel.moveStart('character', -input.value.length);
|
||
result.start = sel.text.length - selLen;
|
||
result.length = selLen
|
||
}
|
||
return result
|
||
};
|
||
/**
|
||
* Copies CSS properties from one element to another.
|
||
*
|
||
* @param {object} $from
|
||
* @param {object} $to
|
||
* @param {array} properties
|
||
*/
|
||
var transferStyles = function ($from, $to, properties) {
|
||
var i, n, styles = {};
|
||
if (properties) {
|
||
for (i = 0, n = properties.length; i < n; i++) {
|
||
styles[properties[i]] = $from.css(properties[i])
|
||
}
|
||
} else {
|
||
styles = $from.css()
|
||
}
|
||
$to.css(styles)
|
||
};
|
||
/**
|
||
* Measures the width of a string within a
|
||
* parent element (in pixels).
|
||
*
|
||
* @param {string} str
|
||
* @param {object} $parent
|
||
* @returns {int}
|
||
*/
|
||
var measureString = function (str, $parent) {
|
||
if (!str) {
|
||
return 0
|
||
}
|
||
var $test = $('<test>').css({
|
||
position: 'absolute',
|
||
top: -99999,
|
||
left: -99999,
|
||
width: 'auto',
|
||
padding: 0,
|
||
whiteSpace: 'pre'
|
||
}).text(str).appendTo('body');
|
||
transferStyles($parent, $test, [
|
||
'letterSpacing',
|
||
'fontSize',
|
||
'fontFamily',
|
||
'fontWeight',
|
||
'textTransform'
|
||
]);
|
||
var width = $test.width();
|
||
$test.remove();
|
||
return width
|
||
};
|
||
/**
|
||
* Sets up an input to grow horizontally as the user
|
||
* types. If the value is changed manually, you can
|
||
* trigger the "update" handler to resize:
|
||
*
|
||
* $input.trigger('update');
|
||
*
|
||
* @param {object} $input
|
||
*/
|
||
var autoGrow = function ($input) {
|
||
var currentWidth = null;
|
||
var update = function (e, options) {
|
||
var value, keyCode, printable, placeholder, width;
|
||
var shift, character, selection;
|
||
e = e || window.event || {};
|
||
options = options || {};
|
||
if (e.metaKey || e.altKey)
|
||
return;
|
||
if (!options.force && $input.data('grow') === false)
|
||
return;
|
||
value = $input.val();
|
||
if (e.type && e.type.toLowerCase() === 'keydown') {
|
||
keyCode = e.keyCode;
|
||
printable = keyCode >= 97 && keyCode <= 122 || keyCode >= 65 && keyCode <= 90 || keyCode >= 48 && keyCode <= 57 || // 0-9
|
||
keyCode === 32 // space
|
||
;
|
||
if (keyCode === KEY_DELETE || keyCode === KEY_BACKSPACE) {
|
||
selection = getSelection($input[0]);
|
||
if (selection.length) {
|
||
value = value.substring(0, selection.start) + value.substring(selection.start + selection.length)
|
||
} else if (keyCode === KEY_BACKSPACE && selection.start) {
|
||
value = value.substring(0, selection.start - 1) + value.substring(selection.start + 1)
|
||
} else if (keyCode === KEY_DELETE && typeof selection.start !== 'undefined') {
|
||
value = value.substring(0, selection.start) + value.substring(selection.start + 1)
|
||
}
|
||
} else if (printable) {
|
||
shift = e.shiftKey;
|
||
character = String.fromCharCode(e.keyCode);
|
||
if (shift)
|
||
character = character.toUpperCase();
|
||
else
|
||
character = character.toLowerCase();
|
||
value += character
|
||
}
|
||
}
|
||
placeholder = $input.attr('placeholder');
|
||
if (!value && placeholder) {
|
||
value = placeholder
|
||
}
|
||
width = measureString(value, $input) + 4;
|
||
if (width !== currentWidth) {
|
||
currentWidth = width;
|
||
$input.width(width);
|
||
$input.triggerHandler('resize')
|
||
}
|
||
};
|
||
$input.on('keydown keyup update blur', update);
|
||
update()
|
||
};
|
||
var Selectize = function ($input, settings) {
|
||
var key, i, n, dir, input, self = this;
|
||
input = $input[0];
|
||
input.selectize = self;
|
||
// detect rtl environment
|
||
var computedStyle = window.getComputedStyle && window.getComputedStyle(input, null);
|
||
dir = computedStyle ? computedStyle.getPropertyValue('direction') : input.currentStyle && input.currentStyle.direction;
|
||
dir = dir || $input.parents('[dir]:first').attr('dir') || '';
|
||
// setup default state
|
||
$.extend(self, {
|
||
order: 0,
|
||
settings: settings,
|
||
$input: $input,
|
||
tabIndex: $input.attr('tabindex') || '',
|
||
tagType: input.tagName.toLowerCase() === 'select' ? TAG_SELECT : TAG_INPUT,
|
||
rtl: /rtl/i.test(dir),
|
||
eventNS: '.selectize' + ++Selectize.count,
|
||
highlightedValue: null,
|
||
isOpen: false,
|
||
isDisabled: false,
|
||
isRequired: $input.is('[required]'),
|
||
isInvalid: false,
|
||
isLocked: false,
|
||
isFocused: false,
|
||
isInputHidden: false,
|
||
isSetup: false,
|
||
isShiftDown: false,
|
||
isCmdDown: false,
|
||
isCtrlDown: false,
|
||
ignoreFocus: false,
|
||
ignoreBlur: false,
|
||
ignoreHover: false,
|
||
hasOptions: false,
|
||
currentResults: null,
|
||
lastValue: '',
|
||
caretPos: 0,
|
||
loading: 0,
|
||
loadedSearches: {},
|
||
$activeOption: null,
|
||
$activeItems: [],
|
||
optgroups: {},
|
||
options: {},
|
||
userOptions: {},
|
||
items: [],
|
||
renderCache: {},
|
||
onSearchChange: settings.loadThrottle === null ? self.onSearchChange : debounce(self.onSearchChange, settings.loadThrottle)
|
||
});
|
||
// search system
|
||
self.sifter = new Sifter(this.options, { diacritics: settings.diacritics });
|
||
// build options table
|
||
if (self.settings.options) {
|
||
for (i = 0, n = self.settings.options.length; i < n; i++) {
|
||
self.registerOption(self.settings.options[i])
|
||
}
|
||
delete self.settings.options
|
||
}
|
||
// build optgroup table
|
||
if (self.settings.optgroups) {
|
||
for (i = 0, n = self.settings.optgroups.length; i < n; i++) {
|
||
self.registerOptionGroup(self.settings.optgroups[i])
|
||
}
|
||
delete self.settings.optgroups
|
||
}
|
||
// option-dependent defaults
|
||
self.settings.mode = self.settings.mode || (self.settings.maxItems === 1 ? 'single' : 'multi');
|
||
if (typeof self.settings.hideSelected !== 'boolean') {
|
||
self.settings.hideSelected = self.settings.mode === 'multi'
|
||
}
|
||
self.initializePlugins(self.settings.plugins);
|
||
self.setupCallbacks();
|
||
self.setupTemplates();
|
||
self.setup()
|
||
};
|
||
// mixins
|
||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||
MicroEvent.mixin(Selectize);
|
||
MicroPlugin.mixin(Selectize);
|
||
// methods
|
||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||
$.extend(Selectize.prototype, {
|
||
/**
|
||
* Creates all elements and sets up event bindings.
|
||
*/
|
||
setup: function () {
|
||
var self = this;
|
||
var settings = self.settings;
|
||
var eventNS = self.eventNS;
|
||
var $window = $(window);
|
||
var $document = $(document);
|
||
var $input = self.$input;
|
||
var $wrapper;
|
||
var $control;
|
||
var $control_input;
|
||
var $dropdown;
|
||
var $dropdown_content;
|
||
var $dropdown_parent;
|
||
var inputMode;
|
||
var timeout_blur;
|
||
var timeout_focus;
|
||
var classes;
|
||
var classes_plugins;
|
||
inputMode = self.settings.mode;
|
||
classes = $input.attr('class') || '';
|
||
$wrapper = $('<div>').addClass(settings.wrapperClass).addClass(classes).addClass(inputMode);
|
||
$control = $('<div>').addClass(settings.inputClass).addClass('items').appendTo($wrapper);
|
||
$control_input = $('<input type="text" autocomplete="off" />').appendTo($control).attr('tabindex', $input.is(':disabled') ? '-1' : self.tabIndex);
|
||
$dropdown_parent = $(settings.dropdownParent || $wrapper);
|
||
$dropdown = $('<div>').addClass(settings.dropdownClass).addClass(inputMode).hide().appendTo($dropdown_parent);
|
||
$dropdown_content = $('<div>').addClass(settings.dropdownContentClass).appendTo($dropdown);
|
||
if (self.settings.copyClassesToDropdown) {
|
||
$dropdown.addClass(classes)
|
||
}
|
||
$wrapper.css({ width: $input[0].style.width });
|
||
if (self.plugins.names.length) {
|
||
classes_plugins = 'plugin-' + self.plugins.names.join(' plugin-');
|
||
$wrapper.addClass(classes_plugins);
|
||
$dropdown.addClass(classes_plugins)
|
||
}
|
||
if ((settings.maxItems === null || settings.maxItems > 1) && self.tagType === TAG_SELECT) {
|
||
$input.attr('multiple', 'multiple')
|
||
}
|
||
if (self.settings.placeholder) {
|
||
$control_input.attr('placeholder', settings.placeholder)
|
||
}
|
||
// if splitOn was not passed in, construct it from the delimiter to allow pasting universally
|
||
if (!self.settings.splitOn && self.settings.delimiter) {
|
||
var delimiterEscaped = self.settings.delimiter.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
|
||
self.settings.splitOn = new RegExp('\\s*' + delimiterEscaped + '+\\s*')
|
||
}
|
||
if ($input.attr('autocorrect')) {
|
||
$control_input.attr('autocorrect', $input.attr('autocorrect'))
|
||
}
|
||
if ($input.attr('autocapitalize')) {
|
||
$control_input.attr('autocapitalize', $input.attr('autocapitalize'))
|
||
}
|
||
self.$wrapper = $wrapper;
|
||
self.$control = $control;
|
||
self.$control_input = $control_input;
|
||
self.$dropdown = $dropdown;
|
||
self.$dropdown_content = $dropdown_content;
|
||
$dropdown.on('mouseenter', '[data-selectable]', function () {
|
||
return self.onOptionHover.apply(self, arguments)
|
||
});
|
||
$dropdown.on('mousedown click', '[data-selectable]', function () {
|
||
return self.onOptionSelect.apply(self, arguments)
|
||
});
|
||
watchChildEvent($control, 'mousedown', '*:not(input)', function () {
|
||
return self.onItemSelect.apply(self, arguments)
|
||
});
|
||
autoGrow($control_input);
|
||
$control.on({
|
||
mousedown: function () {
|
||
return self.onMouseDown.apply(self, arguments)
|
||
},
|
||
click: function () {
|
||
return self.onClick.apply(self, arguments)
|
||
}
|
||
});
|
||
$control_input.on({
|
||
mousedown: function (e) {
|
||
e.stopPropagation()
|
||
},
|
||
keydown: function () {
|
||
return self.onKeyDown.apply(self, arguments)
|
||
},
|
||
keyup: function () {
|
||
return self.onKeyUp.apply(self, arguments)
|
||
},
|
||
keypress: function () {
|
||
return self.onKeyPress.apply(self, arguments)
|
||
},
|
||
resize: function () {
|
||
self.positionDropdown.apply(self, [])
|
||
},
|
||
blur: function () {
|
||
return self.onBlur.apply(self, arguments)
|
||
},
|
||
focus: function () {
|
||
self.ignoreBlur = false;
|
||
return self.onFocus.apply(self, arguments)
|
||
},
|
||
paste: function () {
|
||
return self.onPaste.apply(self, arguments)
|
||
}
|
||
});
|
||
$document.on('keydown' + eventNS, function (e) {
|
||
self.isCmdDown = e[IS_MAC ? 'metaKey' : 'ctrlKey'];
|
||
self.isCtrlDown = e[IS_MAC ? 'altKey' : 'ctrlKey'];
|
||
self.isShiftDown = e.shiftKey
|
||
});
|
||
$document.on('keyup' + eventNS, function (e) {
|
||
if (e.keyCode === KEY_CTRL)
|
||
self.isCtrlDown = false;
|
||
if (e.keyCode === KEY_SHIFT)
|
||
self.isShiftDown = false;
|
||
if (e.keyCode === KEY_CMD)
|
||
self.isCmdDown = false
|
||
});
|
||
$document.on('mousedown' + eventNS, function (e) {
|
||
if (self.isFocused) {
|
||
// prevent events on the dropdown scrollbar from causing the control to blur
|
||
if (e.target === self.$dropdown[0] || e.target.parentNode === self.$dropdown[0]) {
|
||
return false
|
||
}
|
||
// blur on click outside
|
||
if (!self.$control.has(e.target).length && e.target !== self.$control[0]) {
|
||
self.blur(e.target)
|
||
}
|
||
}
|
||
});
|
||
$window.on([
|
||
'scroll' + eventNS,
|
||
'resize' + eventNS
|
||
].join(' '), function () {
|
||
if (self.isOpen) {
|
||
self.positionDropdown.apply(self, arguments)
|
||
}
|
||
});
|
||
$window.on('mousemove' + eventNS, function () {
|
||
self.ignoreHover = false
|
||
});
|
||
// store original children and tab index so that they can be
|
||
// restored when the destroy() method is called.
|
||
this.revertSettings = {
|
||
$children: $input.children().detach(),
|
||
tabindex: $input.attr('tabindex')
|
||
};
|
||
$input.attr('tabindex', -1).hide().after(self.$wrapper);
|
||
if ($.isArray(settings.items)) {
|
||
self.setValue(settings.items);
|
||
delete settings.items
|
||
}
|
||
// feature detect for the validation API
|
||
if (SUPPORTS_VALIDITY_API) {
|
||
$input.on('invalid' + eventNS, function (e) {
|
||
e.preventDefault();
|
||
self.isInvalid = true;
|
||
self.refreshState()
|
||
})
|
||
}
|
||
self.updateOriginalInput();
|
||
self.refreshItems();
|
||
self.refreshState();
|
||
self.updatePlaceholder();
|
||
self.isSetup = true;
|
||
if ($input.is(':disabled')) {
|
||
self.disable()
|
||
}
|
||
self.on('change', this.onChange);
|
||
$input.data('selectize', self);
|
||
$input.addClass('selectized');
|
||
self.trigger('initialize');
|
||
// preload options
|
||
if (settings.preload === true) {
|
||
self.onSearchChange('')
|
||
}
|
||
},
|
||
/**
|
||
* Sets up default rendering functions.
|
||
*/
|
||
setupTemplates: function () {
|
||
var self = this;
|
||
var field_label = self.settings.labelField;
|
||
var field_optgroup = self.settings.optgroupLabelField;
|
||
var templates = {
|
||
'optgroup': function (data) {
|
||
return '<div class="optgroup">' + data.html + '</div>'
|
||
},
|
||
'optgroup_header': function (data, escape) {
|
||
return '<div class="optgroup-header">' + escape(data[field_optgroup]) + '</div>'
|
||
},
|
||
'option': function (data, escape) {
|
||
return '<div class="option">' + escape(data[field_label]) + '</div>'
|
||
},
|
||
'item': function (data, escape) {
|
||
return '<div class="item">' + escape(data[field_label]) + '</div>'
|
||
},
|
||
'option_create': function (data, escape) {
|
||
return '<div class="create">Add <strong>' + escape(data.input) + '</strong>…</div>'
|
||
}
|
||
};
|
||
self.settings.render = $.extend({}, templates, self.settings.render)
|
||
},
|
||
/**
|
||
* Maps fired events to callbacks provided
|
||
* in the settings used when creating the control.
|
||
*/
|
||
setupCallbacks: function () {
|
||
var key, fn, callbacks = {
|
||
'initialize': 'onInitialize',
|
||
'change': 'onChange',
|
||
'item_add': 'onItemAdd',
|
||
'item_remove': 'onItemRemove',
|
||
'clear': 'onClear',
|
||
'option_add': 'onOptionAdd',
|
||
'option_remove': 'onOptionRemove',
|
||
'option_clear': 'onOptionClear',
|
||
'optgroup_add': 'onOptionGroupAdd',
|
||
'optgroup_remove': 'onOptionGroupRemove',
|
||
'optgroup_clear': 'onOptionGroupClear',
|
||
'dropdown_open': 'onDropdownOpen',
|
||
'dropdown_close': 'onDropdownClose',
|
||
'type': 'onType',
|
||
'load': 'onLoad',
|
||
'focus': 'onFocus',
|
||
'blur': 'onBlur'
|
||
};
|
||
for (key in callbacks) {
|
||
if (callbacks.hasOwnProperty(key)) {
|
||
fn = this.settings[callbacks[key]];
|
||
if (fn)
|
||
this.on(key, fn)
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Triggered when the main control element
|
||
* has a click event.
|
||
*
|
||
* @param {object} e
|
||
* @return {boolean}
|
||
*/
|
||
onClick: function (e) {
|
||
var self = this;
|
||
// necessary for mobile webkit devices (manual focus triggering
|
||
// is ignored unless invoked within a click event)
|
||
if (!self.isFocused) {
|
||
self.focus();
|
||
e.preventDefault()
|
||
}
|
||
},
|
||
/**
|
||
* Triggered when the main control element
|
||
* has a mouse down event.
|
||
*
|
||
* @param {object} e
|
||
* @return {boolean}
|
||
*/
|
||
onMouseDown: function (e) {
|
||
var self = this;
|
||
var defaultPrevented = e.isDefaultPrevented();
|
||
var $target = $(e.target);
|
||
if (self.isFocused) {
|
||
// retain focus by preventing native handling. if the
|
||
// event target is the input it should not be modified.
|
||
// otherwise, text selection within the input won't work.
|
||
if (e.target !== self.$control_input[0]) {
|
||
if (self.settings.mode === 'single') {
|
||
// toggle dropdown
|
||
self.isOpen ? self.close() : self.open()
|
||
} else if (!defaultPrevented) {
|
||
self.setActiveItem(null)
|
||
}
|
||
return false
|
||
}
|
||
} else {
|
||
// give control focus
|
||
if (!defaultPrevented) {
|
||
window.setTimeout(function () {
|
||
self.focus()
|
||
}, 0)
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Triggered when the value of the control has been changed.
|
||
* This should propagate the event to the original DOM
|
||
* input / select element.
|
||
*/
|
||
onChange: function () {
|
||
this.$input.trigger('change')
|
||
},
|
||
/**
|
||
* Triggered on <input> paste.
|
||
*
|
||
* @param {object} e
|
||
* @returns {boolean}
|
||
*/
|
||
onPaste: function (e) {
|
||
var self = this;
|
||
if (self.isFull() || self.isInputHidden || self.isLocked) {
|
||
e.preventDefault()
|
||
} else {
|
||
// If a regex or string is included, this will split the pasted
|
||
// input and create Items for each separate value
|
||
if (self.settings.splitOn) {
|
||
setTimeout(function () {
|
||
var splitInput = $.trim(self.$control_input.val() || '').split(self.settings.splitOn);
|
||
for (var i = 0, n = splitInput.length; i < n; i++) {
|
||
self.createItem(splitInput[i])
|
||
}
|
||
}, 0)
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Triggered on <input> keypress.
|
||
*
|
||
* @param {object} e
|
||
* @returns {boolean}
|
||
*/
|
||
onKeyPress: function (e) {
|
||
if (this.isLocked)
|
||
return e && e.preventDefault();
|
||
var character = String.fromCharCode(e.keyCode || e.which);
|
||
if (this.settings.create && this.settings.mode === 'multi' && character === this.settings.delimiter) {
|
||
this.createItem();
|
||
e.preventDefault();
|
||
return false
|
||
}
|
||
},
|
||
/**
|
||
* Triggered on <input> keydown.
|
||
*
|
||
* @param {object} e
|
||
* @returns {boolean}
|
||
*/
|
||
onKeyDown: function (e) {
|
||
var isInput = e.target === this.$control_input[0];
|
||
var self = this;
|
||
if (self.isLocked) {
|
||
if (e.keyCode !== KEY_TAB) {
|
||
e.preventDefault()
|
||
}
|
||
return
|
||
}
|
||
switch (e.keyCode) {
|
||
case KEY_A:
|
||
if (self.isCmdDown) {
|
||
self.selectAll();
|
||
return
|
||
}
|
||
break;
|
||
case KEY_ESC:
|
||
if (self.isOpen) {
|
||
e.preventDefault();
|
||
e.stopPropagation();
|
||
self.close()
|
||
}
|
||
return;
|
||
case KEY_N:
|
||
if (!e.ctrlKey || e.altKey)
|
||
break;
|
||
case KEY_DOWN:
|
||
if (!self.isOpen && self.hasOptions) {
|
||
self.open()
|
||
} else if (self.$activeOption) {
|
||
self.ignoreHover = true;
|
||
var $next = self.getAdjacentOption(self.$activeOption, 1);
|
||
if ($next.length)
|
||
self.setActiveOption($next, true, true)
|
||
}
|
||
e.preventDefault();
|
||
return;
|
||
case KEY_P:
|
||
if (!e.ctrlKey || e.altKey)
|
||
break;
|
||
case KEY_UP:
|
||
if (self.$activeOption) {
|
||
self.ignoreHover = true;
|
||
var $prev = self.getAdjacentOption(self.$activeOption, -1);
|
||
if ($prev.length)
|
||
self.setActiveOption($prev, true, true)
|
||
}
|
||
e.preventDefault();
|
||
return;
|
||
case KEY_RETURN:
|
||
if (self.isOpen && self.$activeOption) {
|
||
self.onOptionSelect({ currentTarget: self.$activeOption });
|
||
e.preventDefault()
|
||
}
|
||
return;
|
||
case KEY_LEFT:
|
||
self.advanceSelection(-1, e);
|
||
return;
|
||
case KEY_RIGHT:
|
||
self.advanceSelection(1, e);
|
||
return;
|
||
case KEY_TAB:
|
||
if (self.settings.selectOnTab && self.isOpen && self.$activeOption) {
|
||
self.onOptionSelect({ currentTarget: self.$activeOption });
|
||
// Default behaviour is to jump to the next field, we only want this
|
||
// if the current field doesn't accept any more entries
|
||
if (!self.isFull()) {
|
||
e.preventDefault()
|
||
}
|
||
}
|
||
if (self.settings.create && self.createItem()) {
|
||
e.preventDefault()
|
||
}
|
||
return;
|
||
case KEY_BACKSPACE:
|
||
case KEY_DELETE:
|
||
self.deleteSelection(e);
|
||
return
|
||
}
|
||
if ((self.isFull() || self.isInputHidden) && !(IS_MAC ? e.metaKey : e.ctrlKey)) {
|
||
e.preventDefault();
|
||
return
|
||
}
|
||
},
|
||
/**
|
||
* Triggered on <input> keyup.
|
||
*
|
||
* @param {object} e
|
||
* @returns {boolean}
|
||
*/
|
||
onKeyUp: function (e) {
|
||
var self = this;
|
||
if (self.isLocked)
|
||
return e && e.preventDefault();
|
||
var value = self.$control_input.val() || '';
|
||
if (self.lastValue !== value) {
|
||
self.lastValue = value;
|
||
self.onSearchChange(value);
|
||
self.refreshOptions();
|
||
self.trigger('type', value)
|
||
}
|
||
},
|
||
/**
|
||
* Invokes the user-provide option provider / loader.
|
||
*
|
||
* Note: this function is debounced in the Selectize
|
||
* constructor (by `settings.loadDelay` milliseconds)
|
||
*
|
||
* @param {string} value
|
||
*/
|
||
onSearchChange: function (value) {
|
||
var self = this;
|
||
var fn = self.settings.load;
|
||
if (!fn)
|
||
return;
|
||
if (self.loadedSearches.hasOwnProperty(value))
|
||
return;
|
||
self.loadedSearches[value] = true;
|
||
self.load(function (callback) {
|
||
fn.apply(self, [
|
||
value,
|
||
callback
|
||
])
|
||
})
|
||
},
|
||
/**
|
||
* Triggered on <input> focus.
|
||
*
|
||
* @param {object} e (optional)
|
||
* @returns {boolean}
|
||
*/
|
||
onFocus: function (e) {
|
||
var self = this;
|
||
var wasFocused = self.isFocused;
|
||
if (self.isDisabled) {
|
||
self.blur();
|
||
e && e.preventDefault();
|
||
return false
|
||
}
|
||
if (self.ignoreFocus)
|
||
return;
|
||
self.isFocused = true;
|
||
if (self.settings.preload === 'focus')
|
||
self.onSearchChange('');
|
||
if (!wasFocused)
|
||
self.trigger('focus');
|
||
if (!self.$activeItems.length) {
|
||
self.showInput();
|
||
self.setActiveItem(null);
|
||
self.refreshOptions(!!self.settings.openOnFocus)
|
||
}
|
||
self.refreshState()
|
||
},
|
||
/**
|
||
* Triggered on <input> blur.
|
||
*
|
||
* @param {object} e
|
||
* @param {Element} dest
|
||
*/
|
||
onBlur: function (e, dest) {
|
||
var self = this;
|
||
if (!self.isFocused)
|
||
return;
|
||
self.isFocused = false;
|
||
if (self.ignoreFocus) {
|
||
return
|
||
} else if (!self.ignoreBlur && document.activeElement === self.$dropdown_content[0]) {
|
||
// necessary to prevent IE closing the dropdown when the scrollbar is clicked
|
||
self.ignoreBlur = true;
|
||
self.onFocus(e);
|
||
return
|
||
}
|
||
var deactivate = function () {
|
||
self.close();
|
||
self.setTextboxValue('');
|
||
self.setActiveItem(null);
|
||
self.setActiveOption(null);
|
||
self.setCaret(self.items.length);
|
||
self.refreshState();
|
||
// IE11 bug: element still marked as active
|
||
(dest || document.body).focus();
|
||
self.ignoreFocus = false;
|
||
self.trigger('blur')
|
||
};
|
||
self.ignoreFocus = true;
|
||
if (self.settings.create && self.settings.createOnBlur) {
|
||
self.createItem(null, false, deactivate)
|
||
} else {
|
||
deactivate()
|
||
}
|
||
},
|
||
/**
|
||
* Triggered when the user rolls over
|
||
* an option in the autocomplete dropdown menu.
|
||
*
|
||
* @param {object} e
|
||
* @returns {boolean}
|
||
*/
|
||
onOptionHover: function (e) {
|
||
if (this.ignoreHover)
|
||
return;
|
||
this.setActiveOption(e.currentTarget, false)
|
||
},
|
||
/**
|
||
* Triggered when the user clicks on an option
|
||
* in the autocomplete dropdown menu.
|
||
*
|
||
* @param {object} e
|
||
* @returns {boolean}
|
||
*/
|
||
onOptionSelect: function (e) {
|
||
var value, $target, $option, self = this;
|
||
if (e.preventDefault) {
|
||
e.preventDefault();
|
||
e.stopPropagation()
|
||
}
|
||
$target = $(e.currentTarget);
|
||
if ($target.hasClass('create')) {
|
||
self.createItem(null, function () {
|
||
if (self.settings.closeAfterSelect) {
|
||
self.close()
|
||
}
|
||
})
|
||
} else {
|
||
value = $target.attr('data-value');
|
||
if (typeof value !== 'undefined') {
|
||
self.lastQuery = null;
|
||
self.setTextboxValue('');
|
||
self.addItem(value);
|
||
if (self.settings.closeAfterSelect) {
|
||
self.close()
|
||
} else if (!self.settings.hideSelected && e.type && /mouse/.test(e.type)) {
|
||
self.setActiveOption(self.getOption(value))
|
||
}
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Triggered when the user clicks on an item
|
||
* that has been selected.
|
||
*
|
||
* @param {object} e
|
||
* @returns {boolean}
|
||
*/
|
||
onItemSelect: function (e) {
|
||
var self = this;
|
||
if (self.isLocked)
|
||
return;
|
||
if (self.settings.mode === 'multi') {
|
||
e.preventDefault();
|
||
self.setActiveItem(e.currentTarget, e)
|
||
}
|
||
},
|
||
/**
|
||
* Invokes the provided method that provides
|
||
* results to a callback---which are then added
|
||
* as options to the control.
|
||
*
|
||
* @param {function} fn
|
||
*/
|
||
load: function (fn) {
|
||
var self = this;
|
||
var $wrapper = self.$wrapper.addClass(self.settings.loadingClass);
|
||
self.loading++;
|
||
fn.apply(self, [function (results) {
|
||
self.loading = Math.max(self.loading - 1, 0);
|
||
if (results && results.length) {
|
||
self.addOption(results);
|
||
self.refreshOptions(self.isFocused && !self.isInputHidden)
|
||
}
|
||
if (!self.loading) {
|
||
$wrapper.removeClass(self.settings.loadingClass)
|
||
}
|
||
self.trigger('load', results)
|
||
}])
|
||
},
|
||
/**
|
||
* Sets the input field of the control to the specified value.
|
||
*
|
||
* @param {string} value
|
||
*/
|
||
setTextboxValue: function (value) {
|
||
var $input = this.$control_input;
|
||
var changed = $input.val() !== value;
|
||
if (changed) {
|
||
$input.val(value).triggerHandler('update');
|
||
this.lastValue = value
|
||
}
|
||
},
|
||
/**
|
||
* Returns the value of the control. If multiple items
|
||
* can be selected (e.g. <select multiple>), this returns
|
||
* an array. If only one item can be selected, this
|
||
* returns a string.
|
||
*
|
||
* @returns {mixed}
|
||
*/
|
||
getValue: function () {
|
||
if (this.tagType === TAG_SELECT && this.$input.attr('multiple')) {
|
||
return this.items
|
||
} else {
|
||
return this.items.join(this.settings.delimiter)
|
||
}
|
||
},
|
||
/**
|
||
* Resets the selected items to the given value.
|
||
*
|
||
* @param {mixed} value
|
||
*/
|
||
setValue: function (value, silent) {
|
||
var events = silent ? [] : ['change'];
|
||
debounce_events(this, events, function () {
|
||
this.clear(silent);
|
||
this.addItems(value, silent)
|
||
})
|
||
},
|
||
/**
|
||
* Sets the selected item.
|
||
*
|
||
* @param {object} $item
|
||
* @param {object} e (optional)
|
||
*/
|
||
setActiveItem: function ($item, e) {
|
||
var self = this;
|
||
var eventName;
|
||
var i, idx, begin, end, item, swap;
|
||
var $last;
|
||
if (self.settings.mode === 'single')
|
||
return;
|
||
$item = $($item);
|
||
// clear the active selection
|
||
if (!$item.length) {
|
||
$(self.$activeItems).removeClass('active');
|
||
self.$activeItems = [];
|
||
if (self.isFocused) {
|
||
self.showInput()
|
||
}
|
||
return
|
||
}
|
||
// modify selection
|
||
eventName = e && e.type.toLowerCase();
|
||
if (eventName === 'mousedown' && self.isShiftDown && self.$activeItems.length) {
|
||
$last = self.$control.children('.active:last');
|
||
begin = Array.prototype.indexOf.apply(self.$control[0].childNodes, [$last[0]]);
|
||
end = Array.prototype.indexOf.apply(self.$control[0].childNodes, [$item[0]]);
|
||
if (begin > end) {
|
||
swap = begin;
|
||
begin = end;
|
||
end = swap
|
||
}
|
||
for (i = begin; i <= end; i++) {
|
||
item = self.$control[0].childNodes[i];
|
||
if (self.$activeItems.indexOf(item) === -1) {
|
||
$(item).addClass('active');
|
||
self.$activeItems.push(item)
|
||
}
|
||
}
|
||
e.preventDefault()
|
||
} else if (eventName === 'mousedown' && self.isCtrlDown || eventName === 'keydown' && this.isShiftDown) {
|
||
if ($item.hasClass('active')) {
|
||
idx = self.$activeItems.indexOf($item[0]);
|
||
self.$activeItems.splice(idx, 1);
|
||
$item.removeClass('active')
|
||
} else {
|
||
self.$activeItems.push($item.addClass('active')[0])
|
||
}
|
||
} else {
|
||
$(self.$activeItems).removeClass('active');
|
||
self.$activeItems = [$item.addClass('active')[0]]
|
||
}
|
||
// ensure control has focus
|
||
self.hideInput();
|
||
if (!this.isFocused) {
|
||
self.focus()
|
||
}
|
||
},
|
||
/**
|
||
* Sets the selected item in the dropdown menu
|
||
* of available options.
|
||
*
|
||
* @param {object} $object
|
||
* @param {boolean} scroll
|
||
* @param {boolean} animate
|
||
*/
|
||
setActiveOption: function ($option, scroll, animate) {
|
||
var height_menu, height_item, y;
|
||
var scroll_top, scroll_bottom;
|
||
var self = this;
|
||
if (self.$activeOption)
|
||
self.$activeOption.removeClass('active');
|
||
self.$activeOption = null;
|
||
$option = $($option);
|
||
if (!$option.length)
|
||
return;
|
||
self.$activeOption = $option.addClass('active');
|
||
if (scroll || !isset(scroll)) {
|
||
height_menu = self.$dropdown_content.height();
|
||
height_item = self.$activeOption.outerHeight(true);
|
||
scroll = self.$dropdown_content.scrollTop() || 0;
|
||
y = self.$activeOption.offset().top - self.$dropdown_content.offset().top + scroll;
|
||
scroll_top = y;
|
||
scroll_bottom = y - height_menu + height_item;
|
||
if (y + height_item > height_menu + scroll) {
|
||
self.$dropdown_content.stop().animate({ scrollTop: scroll_bottom }, animate ? self.settings.scrollDuration : 0)
|
||
} else if (y < scroll) {
|
||
self.$dropdown_content.stop().animate({ scrollTop: scroll_top }, animate ? self.settings.scrollDuration : 0)
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Selects all items (CTRL + A).
|
||
*/
|
||
selectAll: function () {
|
||
var self = this;
|
||
if (self.settings.mode === 'single')
|
||
return;
|
||
self.$activeItems = Array.prototype.slice.apply(self.$control.children(':not(input)').addClass('active'));
|
||
if (self.$activeItems.length) {
|
||
self.hideInput();
|
||
self.close()
|
||
}
|
||
self.focus()
|
||
},
|
||
/**
|
||
* Hides the input element out of view, while
|
||
* retaining its focus.
|
||
*/
|
||
hideInput: function () {
|
||
var self = this;
|
||
self.setTextboxValue('');
|
||
self.$control_input.css({
|
||
opacity: 0,
|
||
position: 'absolute',
|
||
left: self.rtl ? 10000 : -10000
|
||
});
|
||
self.isInputHidden = true
|
||
},
|
||
/**
|
||
* Restores input visibility.
|
||
*/
|
||
showInput: function () {
|
||
this.$control_input.css({
|
||
opacity: 1,
|
||
position: 'relative',
|
||
left: 0
|
||
});
|
||
this.isInputHidden = false
|
||
},
|
||
/**
|
||
* Gives the control focus.
|
||
*/
|
||
focus: function () {
|
||
var self = this;
|
||
if (self.isDisabled)
|
||
return;
|
||
self.ignoreFocus = true;
|
||
self.$control_input[0].focus();
|
||
window.setTimeout(function () {
|
||
self.ignoreFocus = false;
|
||
self.onFocus()
|
||
}, 0)
|
||
},
|
||
/**
|
||
* Forces the control out of focus.
|
||
*
|
||
* @param {Element} dest
|
||
*/
|
||
blur: function (dest) {
|
||
this.$control_input[0].blur();
|
||
this.onBlur(null, dest)
|
||
},
|
||
/**
|
||
* Returns a function that scores an object
|
||
* to show how good of a match it is to the
|
||
* provided query.
|
||
*
|
||
* @param {string} query
|
||
* @param {object} options
|
||
* @return {function}
|
||
*/
|
||
getScoreFunction: function (query) {
|
||
return this.sifter.getScoreFunction(query, this.getSearchOptions())
|
||
},
|
||
/**
|
||
* Returns search options for sifter (the system
|
||
* for scoring and sorting results).
|
||
*
|
||
* @see https://github.com/brianreavis/sifter.js
|
||
* @return {object}
|
||
*/
|
||
getSearchOptions: function () {
|
||
var settings = this.settings;
|
||
var sort = settings.sortField;
|
||
if (typeof sort === 'string') {
|
||
sort = [{ field: sort }]
|
||
}
|
||
return {
|
||
fields: settings.searchField,
|
||
conjunction: settings.searchConjunction,
|
||
sort: sort
|
||
}
|
||
},
|
||
/**
|
||
* Searches through available options and returns
|
||
* a sorted array of matches.
|
||
*
|
||
* Returns an object containing:
|
||
*
|
||
* - query {string}
|
||
* - tokens {array}
|
||
* - total {int}
|
||
* - items {array}
|
||
*
|
||
* @param {string} query
|
||
* @returns {object}
|
||
*/
|
||
search: function (query) {
|
||
var i, value, score, result, calculateScore;
|
||
var self = this;
|
||
var settings = self.settings;
|
||
var options = this.getSearchOptions();
|
||
// validate user-provided result scoring function
|
||
if (settings.score) {
|
||
calculateScore = self.settings.score.apply(this, [query]);
|
||
if (typeof calculateScore !== 'function') {
|
||
throw new Error('Selectize "score" setting must be a function that returns a function')
|
||
}
|
||
}
|
||
// perform search
|
||
if (query !== self.lastQuery) {
|
||
self.lastQuery = query;
|
||
result = self.sifter.search(query, $.extend(options, { score: calculateScore }));
|
||
self.currentResults = result
|
||
} else {
|
||
result = $.extend(true, {}, self.currentResults)
|
||
}
|
||
// filter out selected items
|
||
if (settings.hideSelected) {
|
||
for (i = result.items.length - 1; i >= 0; i--) {
|
||
if (self.items.indexOf(hash_key(result.items[i].id)) !== -1) {
|
||
result.items.splice(i, 1)
|
||
}
|
||
}
|
||
}
|
||
return result
|
||
},
|
||
/**
|
||
* Refreshes the list of available options shown
|
||
* in the autocomplete dropdown menu.
|
||
*
|
||
* @param {boolean} triggerDropdown
|
||
*/
|
||
refreshOptions: function (triggerDropdown) {
|
||
var i, j, k, n, groups, groups_order, option, option_html, optgroup, optgroups, html, html_children, has_create_option;
|
||
var $active, $active_before, $create;
|
||
if (typeof triggerDropdown === 'undefined') {
|
||
triggerDropdown = true
|
||
}
|
||
var self = this;
|
||
var query = $.trim(self.$control_input.val());
|
||
var results = self.search(query);
|
||
var $dropdown_content = self.$dropdown_content;
|
||
var active_before = self.$activeOption && hash_key(self.$activeOption.attr('data-value'));
|
||
// build markup
|
||
n = results.items.length;
|
||
if (typeof self.settings.maxOptions === 'number') {
|
||
n = Math.min(n, self.settings.maxOptions)
|
||
}
|
||
// render and group available options individually
|
||
groups = {};
|
||
groups_order = [];
|
||
for (i = 0; i < n; i++) {
|
||
option = self.options[results.items[i].id];
|
||
option_html = self.render('option', option);
|
||
optgroup = option[self.settings.optgroupField] || '';
|
||
optgroups = $.isArray(optgroup) ? optgroup : [optgroup];
|
||
for (j = 0, k = optgroups && optgroups.length; j < k; j++) {
|
||
optgroup = optgroups[j];
|
||
if (!self.optgroups.hasOwnProperty(optgroup)) {
|
||
optgroup = ''
|
||
}
|
||
if (!groups.hasOwnProperty(optgroup)) {
|
||
groups[optgroup] = [];
|
||
groups_order.push(optgroup)
|
||
}
|
||
groups[optgroup].push(option_html)
|
||
}
|
||
}
|
||
// sort optgroups
|
||
if (this.settings.lockOptgroupOrder) {
|
||
groups_order.sort(function (a, b) {
|
||
var a_order = self.optgroups[a].$order || 0;
|
||
var b_order = self.optgroups[b].$order || 0;
|
||
return a_order - b_order
|
||
})
|
||
}
|
||
// render optgroup headers & join groups
|
||
html = [];
|
||
for (i = 0, n = groups_order.length; i < n; i++) {
|
||
optgroup = groups_order[i];
|
||
if (self.optgroups.hasOwnProperty(optgroup) && groups[optgroup].length) {
|
||
// render the optgroup header and options within it,
|
||
// then pass it to the wrapper template
|
||
html_children = self.render('optgroup_header', self.optgroups[optgroup]) || '';
|
||
html_children += groups[optgroup].join('');
|
||
html.push(self.render('optgroup', $.extend({}, self.optgroups[optgroup], { html: html_children })))
|
||
} else {
|
||
html.push(groups[optgroup].join(''))
|
||
}
|
||
}
|
||
$dropdown_content.html(html.join(''));
|
||
// highlight matching terms inline
|
||
if (self.settings.highlight && results.query.length && results.tokens.length) {
|
||
for (i = 0, n = results.tokens.length; i < n; i++) {
|
||
highlight($dropdown_content, results.tokens[i].regex)
|
||
}
|
||
}
|
||
// add "selected" class to selected options
|
||
if (!self.settings.hideSelected) {
|
||
for (i = 0, n = self.items.length; i < n; i++) {
|
||
self.getOption(self.items[i]).addClass('selected')
|
||
}
|
||
}
|
||
// add create option
|
||
has_create_option = self.canCreate(query);
|
||
if (has_create_option) {
|
||
$dropdown_content.prepend(self.render('option_create', { input: query }));
|
||
$create = $($dropdown_content[0].childNodes[0])
|
||
}
|
||
// activate
|
||
self.hasOptions = results.items.length > 0 || has_create_option;
|
||
if (self.hasOptions) {
|
||
if (results.items.length > 0) {
|
||
$active_before = active_before && self.getOption(active_before);
|
||
if ($active_before && $active_before.length) {
|
||
$active = $active_before
|
||
} else if (self.settings.mode === 'single' && self.items.length) {
|
||
$active = self.getOption(self.items[0])
|
||
}
|
||
if (!$active || !$active.length) {
|
||
if ($create && !self.settings.addPrecedence) {
|
||
$active = self.getAdjacentOption($create, 1)
|
||
} else {
|
||
$active = $dropdown_content.find('[data-selectable]:first')
|
||
}
|
||
}
|
||
} else {
|
||
$active = $create
|
||
}
|
||
self.setActiveOption($active);
|
||
if (triggerDropdown && !self.isOpen) {
|
||
self.open()
|
||
}
|
||
} else {
|
||
self.setActiveOption(null);
|
||
if (triggerDropdown && self.isOpen) {
|
||
self.close()
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Adds an available option. If it already exists,
|
||
* nothing will happen. Note: this does not refresh
|
||
* the options list dropdown (use `refreshOptions`
|
||
* for that).
|
||
*
|
||
* Usage:
|
||
*
|
||
* this.addOption(data)
|
||
*
|
||
* @param {object|array} data
|
||
*/
|
||
addOption: function (data) {
|
||
var i, n, value, self = this;
|
||
if ($.isArray(data)) {
|
||
for (i = 0, n = data.length; i < n; i++) {
|
||
self.addOption(data[i])
|
||
}
|
||
return
|
||
}
|
||
if (value = self.registerOption(data)) {
|
||
self.userOptions[value] = true;
|
||
self.lastQuery = null;
|
||
self.trigger('option_add', value, data)
|
||
}
|
||
},
|
||
/**
|
||
* Registers an option to the pool of options.
|
||
*
|
||
* @param {object} data
|
||
* @return {boolean|string}
|
||
*/
|
||
registerOption: function (data) {
|
||
var key = hash_key(data[this.settings.valueField]);
|
||
if (!key || this.options.hasOwnProperty(key))
|
||
return false;
|
||
data.$order = data.$order || ++this.order;
|
||
this.options[key] = data;
|
||
return key
|
||
},
|
||
/**
|
||
* Registers an option group to the pool of option groups.
|
||
*
|
||
* @param {object} data
|
||
* @return {boolean|string}
|
||
*/
|
||
registerOptionGroup: function (data) {
|
||
var key = hash_key(data[this.settings.optgroupValueField]);
|
||
if (!key)
|
||
return false;
|
||
data.$order = data.$order || ++this.order;
|
||
this.optgroups[key] = data;
|
||
return key
|
||
},
|
||
/**
|
||
* Registers a new optgroup for options
|
||
* to be bucketed into.
|
||
*
|
||
* @param {string} id
|
||
* @param {object} data
|
||
*/
|
||
addOptionGroup: function (id, data) {
|
||
data[this.settings.optgroupValueField] = id;
|
||
if (id = this.registerOptionGroup(data)) {
|
||
this.trigger('optgroup_add', id, data)
|
||
}
|
||
},
|
||
/**
|
||
* Removes an existing option group.
|
||
*
|
||
* @param {string} id
|
||
*/
|
||
removeOptionGroup: function (id) {
|
||
if (this.optgroups.hasOwnProperty(id)) {
|
||
delete this.optgroups[id];
|
||
this.renderCache = {};
|
||
this.trigger('optgroup_remove', id)
|
||
}
|
||
},
|
||
/**
|
||
* Clears all existing option groups.
|
||
*/
|
||
clearOptionGroups: function () {
|
||
this.optgroups = {};
|
||
this.renderCache = {};
|
||
this.trigger('optgroup_clear')
|
||
},
|
||
/**
|
||
* Updates an option available for selection. If
|
||
* it is visible in the selected items or options
|
||
* dropdown, it will be re-rendered automatically.
|
||
*
|
||
* @param {string} value
|
||
* @param {object} data
|
||
*/
|
||
updateOption: function (value, data) {
|
||
var self = this;
|
||
var $item, $item_new;
|
||
var value_new, index_item, cache_items, cache_options, order_old;
|
||
value = hash_key(value);
|
||
value_new = hash_key(data[self.settings.valueField]);
|
||
// sanity checks
|
||
if (value === null)
|
||
return;
|
||
if (!self.options.hasOwnProperty(value))
|
||
return;
|
||
if (typeof value_new !== 'string')
|
||
throw new Error('Value must be set in option data');
|
||
order_old = self.options[value].$order;
|
||
// update references
|
||
if (value_new !== value) {
|
||
delete self.options[value];
|
||
index_item = self.items.indexOf(value);
|
||
if (index_item !== -1) {
|
||
self.items.splice(index_item, 1, value_new)
|
||
}
|
||
}
|
||
data.$order = data.$order || order_old;
|
||
self.options[value_new] = data;
|
||
// invalidate render cache
|
||
cache_items = self.renderCache['item'];
|
||
cache_options = self.renderCache['option'];
|
||
if (cache_items) {
|
||
delete cache_items[value];
|
||
delete cache_items[value_new]
|
||
}
|
||
if (cache_options) {
|
||
delete cache_options[value];
|
||
delete cache_options[value_new]
|
||
}
|
||
// update the item if it's selected
|
||
if (self.items.indexOf(value_new) !== -1) {
|
||
$item = self.getItem(value);
|
||
$item_new = $(self.render('item', data));
|
||
if ($item.hasClass('active'))
|
||
$item_new.addClass('active');
|
||
$item.replaceWith($item_new)
|
||
}
|
||
// invalidate last query because we might have updated the sortField
|
||
self.lastQuery = null;
|
||
// update dropdown contents
|
||
if (self.isOpen) {
|
||
self.refreshOptions(false)
|
||
}
|
||
},
|
||
/**
|
||
* Removes a single option.
|
||
*
|
||
* @param {string} value
|
||
* @param {boolean} silent
|
||
*/
|
||
removeOption: function (value, silent) {
|
||
var self = this;
|
||
value = hash_key(value);
|
||
var cache_items = self.renderCache['item'];
|
||
var cache_options = self.renderCache['option'];
|
||
if (cache_items)
|
||
delete cache_items[value];
|
||
if (cache_options)
|
||
delete cache_options[value];
|
||
delete self.userOptions[value];
|
||
delete self.options[value];
|
||
self.lastQuery = null;
|
||
self.trigger('option_remove', value);
|
||
self.removeItem(value, silent)
|
||
},
|
||
/**
|
||
* Clears all options.
|
||
*/
|
||
clearOptions: function () {
|
||
var self = this;
|
||
self.loadedSearches = {};
|
||
self.userOptions = {};
|
||
self.renderCache = {};
|
||
self.options = self.sifter.items = {};
|
||
self.lastQuery = null;
|
||
self.trigger('option_clear');
|
||
self.clear()
|
||
},
|
||
/**
|
||
* Returns the jQuery element of the option
|
||
* matching the given value.
|
||
*
|
||
* @param {string} value
|
||
* @returns {object}
|
||
*/
|
||
getOption: function (value) {
|
||
return this.getElementWithValue(value, this.$dropdown_content.find('[data-selectable]'))
|
||
},
|
||
/**
|
||
* Returns the jQuery element of the next or
|
||
* previous selectable option.
|
||
*
|
||
* @param {object} $option
|
||
* @param {int} direction can be 1 for next or -1 for previous
|
||
* @return {object}
|
||
*/
|
||
getAdjacentOption: function ($option, direction) {
|
||
var $options = this.$dropdown.find('[data-selectable]');
|
||
var index = $options.index($option) + direction;
|
||
return index >= 0 && index < $options.length ? $options.eq(index) : $()
|
||
},
|
||
/**
|
||
* Finds the first element with a "data-value" attribute
|
||
* that matches the given value.
|
||
*
|
||
* @param {mixed} value
|
||
* @param {object} $els
|
||
* @return {object}
|
||
*/
|
||
getElementWithValue: function (value, $els) {
|
||
value = hash_key(value);
|
||
if (typeof value !== 'undefined' && value !== null) {
|
||
for (var i = 0, n = $els.length; i < n; i++) {
|
||
if ($els[i].getAttribute('data-value') === value) {
|
||
return $($els[i])
|
||
}
|
||
}
|
||
}
|
||
return $()
|
||
},
|
||
/**
|
||
* Returns the jQuery element of the item
|
||
* matching the given value.
|
||
*
|
||
* @param {string} value
|
||
* @returns {object}
|
||
*/
|
||
getItem: function (value) {
|
||
return this.getElementWithValue(value, this.$control.children())
|
||
},
|
||
/**
|
||
* "Selects" multiple items at once. Adds them to the list
|
||
* at the current caret position.
|
||
*
|
||
* @param {string} value
|
||
* @param {boolean} silent
|
||
*/
|
||
addItems: function (values, silent) {
|
||
var items = $.isArray(values) ? values : [values];
|
||
for (var i = 0, n = items.length; i < n; i++) {
|
||
this.isPending = i < n - 1;
|
||
this.addItem(items[i], silent)
|
||
}
|
||
},
|
||
/**
|
||
* "Selects" an item. Adds it to the list
|
||
* at the current caret position.
|
||
*
|
||
* @param {string} value
|
||
* @param {boolean} silent
|
||
*/
|
||
addItem: function (value, silent) {
|
||
var events = silent ? [] : ['change'];
|
||
debounce_events(this, events, function () {
|
||
var $item, $option, $options;
|
||
var self = this;
|
||
var inputMode = self.settings.mode;
|
||
var i, active, value_next, wasFull;
|
||
value = hash_key(value);
|
||
if (self.items.indexOf(value) !== -1) {
|
||
if (inputMode === 'single')
|
||
self.close();
|
||
return
|
||
}
|
||
if (!self.options.hasOwnProperty(value))
|
||
return;
|
||
if (inputMode === 'single')
|
||
self.clear(silent);
|
||
if (inputMode === 'multi' && self.isFull())
|
||
return;
|
||
$item = $(self.render('item', self.options[value]));
|
||
wasFull = self.isFull();
|
||
self.items.splice(self.caretPos, 0, value);
|
||
self.insertAtCaret($item);
|
||
if (!self.isPending || !wasFull && self.isFull()) {
|
||
self.refreshState()
|
||
}
|
||
if (self.isSetup) {
|
||
$options = self.$dropdown_content.find('[data-selectable]');
|
||
// update menu / remove the option (if this is not one item being added as part of series)
|
||
if (!self.isPending) {
|
||
$option = self.getOption(value);
|
||
value_next = self.getAdjacentOption($option, 1).attr('data-value');
|
||
self.refreshOptions(self.isFocused && inputMode !== 'single');
|
||
if (value_next) {
|
||
self.setActiveOption(self.getOption(value_next))
|
||
}
|
||
}
|
||
// hide the menu if the maximum number of items have been selected or no options are left
|
||
if (!$options.length || self.isFull()) {
|
||
self.close()
|
||
} else {
|
||
self.positionDropdown()
|
||
}
|
||
self.updatePlaceholder();
|
||
self.trigger('item_add', value, $item);
|
||
self.updateOriginalInput({ silent: silent })
|
||
}
|
||
})
|
||
},
|
||
/**
|
||
* Removes the selected item matching
|
||
* the provided value.
|
||
*
|
||
* @param {string} value
|
||
*/
|
||
removeItem: function (value, silent) {
|
||
var self = this;
|
||
var $item, i, idx;
|
||
$item = typeof value === 'object' ? value : self.getItem(value);
|
||
value = hash_key($item.attr('data-value'));
|
||
i = self.items.indexOf(value);
|
||
if (i !== -1) {
|
||
$item.remove();
|
||
if ($item.hasClass('active')) {
|
||
idx = self.$activeItems.indexOf($item[0]);
|
||
self.$activeItems.splice(idx, 1)
|
||
}
|
||
self.items.splice(i, 1);
|
||
self.lastQuery = null;
|
||
if (!self.settings.persist && self.userOptions.hasOwnProperty(value)) {
|
||
self.removeOption(value, silent)
|
||
}
|
||
if (i < self.caretPos) {
|
||
self.setCaret(self.caretPos - 1)
|
||
}
|
||
self.refreshState();
|
||
self.updatePlaceholder();
|
||
self.updateOriginalInput({ silent: silent });
|
||
self.positionDropdown();
|
||
self.trigger('item_remove', value, $item)
|
||
}
|
||
},
|
||
/**
|
||
* Invokes the `create` method provided in the
|
||
* selectize options that should provide the data
|
||
* for the new item, given the user input.
|
||
*
|
||
* Once this completes, it will be added
|
||
* to the item list.
|
||
*
|
||
* @param {string} value
|
||
* @param {boolean} [triggerDropdown]
|
||
* @param {function} [callback]
|
||
* @return {boolean}
|
||
*/
|
||
createItem: function (input, triggerDropdown) {
|
||
var self = this;
|
||
var caret = self.caretPos;
|
||
input = input || $.trim(self.$control_input.val() || '');
|
||
var callback = arguments[arguments.length - 1];
|
||
if (typeof callback !== 'function')
|
||
callback = function () {
|
||
};
|
||
if (typeof triggerDropdown !== 'boolean') {
|
||
triggerDropdown = true
|
||
}
|
||
if (!self.canCreate(input)) {
|
||
callback();
|
||
return false
|
||
}
|
||
self.lock();
|
||
var setup = typeof self.settings.create === 'function' ? this.settings.create : function (input) {
|
||
var data = {};
|
||
data[self.settings.labelField] = input;
|
||
data[self.settings.valueField] = input;
|
||
return data
|
||
};
|
||
var create = once(function (data) {
|
||
self.unlock();
|
||
if (!data || typeof data !== 'object')
|
||
return callback();
|
||
var value = hash_key(data[self.settings.valueField]);
|
||
if (typeof value !== 'string')
|
||
return callback();
|
||
self.setTextboxValue('');
|
||
self.addOption(data);
|
||
self.setCaret(caret);
|
||
self.addItem(value);
|
||
self.refreshOptions(triggerDropdown && self.settings.mode !== 'single');
|
||
callback(data)
|
||
});
|
||
var output = setup.apply(this, [
|
||
input,
|
||
create
|
||
]);
|
||
if (typeof output !== 'undefined') {
|
||
create(output)
|
||
}
|
||
return true
|
||
},
|
||
/**
|
||
* Re-renders the selected item lists.
|
||
*/
|
||
refreshItems: function () {
|
||
this.lastQuery = null;
|
||
if (this.isSetup) {
|
||
this.addItem(this.items)
|
||
}
|
||
this.refreshState();
|
||
this.updateOriginalInput()
|
||
},
|
||
/**
|
||
* Updates all state-dependent attributes
|
||
* and CSS classes.
|
||
*/
|
||
refreshState: function () {
|
||
var invalid, self = this;
|
||
if (self.isRequired) {
|
||
if (self.items.length)
|
||
self.isInvalid = false;
|
||
self.$control_input.prop('required', invalid)
|
||
}
|
||
self.refreshClasses()
|
||
},
|
||
/**
|
||
* Updates all state-dependent CSS classes.
|
||
*/
|
||
refreshClasses: function () {
|
||
var self = this;
|
||
var isFull = self.isFull();
|
||
var isLocked = self.isLocked;
|
||
self.$wrapper.toggleClass('rtl', self.rtl);
|
||
self.$control.toggleClass('focus', self.isFocused).toggleClass('disabled', self.isDisabled).toggleClass('required', self.isRequired).toggleClass('invalid', self.isInvalid).toggleClass('locked', isLocked).toggleClass('full', isFull).toggleClass('not-full', !isFull).toggleClass('input-active', self.isFocused && !self.isInputHidden).toggleClass('dropdown-active', self.isOpen).toggleClass('has-options', !$.isEmptyObject(self.options)).toggleClass('has-items', self.items.length > 0);
|
||
self.$control_input.data('grow', !isFull && !isLocked)
|
||
},
|
||
/**
|
||
* Determines whether or not more items can be added
|
||
* to the control without exceeding the user-defined maximum.
|
||
*
|
||
* @returns {boolean}
|
||
*/
|
||
isFull: function () {
|
||
return this.settings.maxItems !== null && this.items.length >= this.settings.maxItems
|
||
},
|
||
/**
|
||
* Refreshes the original <select> or <input>
|
||
* element to reflect the current state.
|
||
*/
|
||
updateOriginalInput: function (opts) {
|
||
var i, n, options, label, self = this;
|
||
opts = opts || {};
|
||
if (self.tagType === TAG_SELECT) {
|
||
options = [];
|
||
for (i = 0, n = self.items.length; i < n; i++) {
|
||
label = self.options[self.items[i]][self.settings.labelField] || '';
|
||
options.push('<option value="' + escape_html(self.items[i]) + '" selected="selected">' + escape_html(label) + '</option>')
|
||
}
|
||
if (!options.length && !this.$input.attr('multiple')) {
|
||
options.push('<option value="" selected="selected"></option>')
|
||
}
|
||
self.$input.html(options.join(''))
|
||
} else {
|
||
self.$input.val(self.getValue());
|
||
self.$input.attr('value', self.$input.val())
|
||
}
|
||
if (self.isSetup) {
|
||
if (!opts.silent) {
|
||
self.trigger('change', self.$input.val())
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Shows/hide the input placeholder depending
|
||
* on if there items in the list already.
|
||
*/
|
||
updatePlaceholder: function () {
|
||
if (!this.settings.placeholder)
|
||
return;
|
||
var $input = this.$control_input;
|
||
if (this.items.length) {
|
||
$input.removeAttr('placeholder')
|
||
} else {
|
||
$input.attr('placeholder', this.settings.placeholder)
|
||
}
|
||
$input.triggerHandler('update', { force: true })
|
||
},
|
||
/**
|
||
* Shows the autocomplete dropdown containing
|
||
* the available options.
|
||
*/
|
||
open: function () {
|
||
var self = this;
|
||
if (self.isLocked || self.isOpen || self.settings.mode === 'multi' && self.isFull())
|
||
return;
|
||
self.focus();
|
||
self.isOpen = true;
|
||
self.refreshState();
|
||
self.$dropdown.css({
|
||
visibility: 'hidden',
|
||
display: 'block'
|
||
});
|
||
self.positionDropdown();
|
||
self.$dropdown.css({ visibility: 'visible' });
|
||
self.trigger('dropdown_open', self.$dropdown)
|
||
},
|
||
/**
|
||
* Closes the autocomplete dropdown menu.
|
||
*/
|
||
close: function () {
|
||
var self = this;
|
||
var trigger = self.isOpen;
|
||
if (self.settings.mode === 'single' && self.items.length) {
|
||
self.hideInput()
|
||
}
|
||
self.isOpen = false;
|
||
self.$dropdown.hide();
|
||
self.setActiveOption(null);
|
||
self.refreshState();
|
||
if (trigger)
|
||
self.trigger('dropdown_close', self.$dropdown)
|
||
},
|
||
/**
|
||
* Calculates and applies the appropriate
|
||
* position of the dropdown.
|
||
*/
|
||
positionDropdown: function () {
|
||
var $control = this.$control;
|
||
var offset = this.settings.dropdownParent === 'body' ? $control.offset() : $control.position();
|
||
offset.top += $control.outerHeight(true);
|
||
this.$dropdown.css({
|
||
width: $control.outerWidth(),
|
||
top: offset.top,
|
||
left: offset.left
|
||
})
|
||
},
|
||
/**
|
||
* Resets / clears all selected items
|
||
* from the control.
|
||
*
|
||
* @param {boolean} silent
|
||
*/
|
||
clear: function (silent) {
|
||
var self = this;
|
||
if (!self.items.length)
|
||
return;
|
||
self.$control.children(':not(input)').remove();
|
||
self.items = [];
|
||
self.lastQuery = null;
|
||
self.setCaret(0);
|
||
self.setActiveItem(null);
|
||
self.updatePlaceholder();
|
||
self.updateOriginalInput({ silent: silent });
|
||
self.refreshState();
|
||
self.showInput();
|
||
self.trigger('clear')
|
||
},
|
||
/**
|
||
* A helper method for inserting an element
|
||
* at the current caret position.
|
||
*
|
||
* @param {object} $el
|
||
*/
|
||
insertAtCaret: function ($el) {
|
||
var caret = Math.min(this.caretPos, this.items.length);
|
||
if (caret === 0) {
|
||
this.$control.prepend($el)
|
||
} else {
|
||
$(this.$control[0].childNodes[caret]).before($el)
|
||
}
|
||
this.setCaret(caret + 1)
|
||
},
|
||
/**
|
||
* Removes the current selected item(s).
|
||
*
|
||
* @param {object} e (optional)
|
||
* @returns {boolean}
|
||
*/
|
||
deleteSelection: function (e) {
|
||
var i, n, direction, selection, values, caret, option_select, $option_select, $tail;
|
||
var self = this;
|
||
direction = e && e.keyCode === KEY_BACKSPACE ? -1 : 1;
|
||
selection = getSelection(self.$control_input[0]);
|
||
if (self.$activeOption && !self.settings.hideSelected) {
|
||
option_select = self.getAdjacentOption(self.$activeOption, -1).attr('data-value')
|
||
}
|
||
// determine items that will be removed
|
||
values = [];
|
||
if (self.$activeItems.length) {
|
||
$tail = self.$control.children('.active:' + (direction > 0 ? 'last' : 'first'));
|
||
caret = self.$control.children(':not(input)').index($tail);
|
||
if (direction > 0) {
|
||
caret++
|
||
}
|
||
for (i = 0, n = self.$activeItems.length; i < n; i++) {
|
||
values.push($(self.$activeItems[i]).attr('data-value'))
|
||
}
|
||
if (e) {
|
||
e.preventDefault();
|
||
e.stopPropagation()
|
||
}
|
||
} else if ((self.isFocused || self.settings.mode === 'single') && self.items.length) {
|
||
if (direction < 0 && selection.start === 0 && selection.length === 0) {
|
||
values.push(self.items[self.caretPos - 1])
|
||
} else if (direction > 0 && selection.start === self.$control_input.val().length) {
|
||
values.push(self.items[self.caretPos])
|
||
}
|
||
}
|
||
// allow the callback to abort
|
||
if (!values.length || typeof self.settings.onDelete === 'function' && self.settings.onDelete.apply(self, [values]) === false) {
|
||
return false
|
||
}
|
||
// perform removal
|
||
if (typeof caret !== 'undefined') {
|
||
self.setCaret(caret)
|
||
}
|
||
while (values.length) {
|
||
self.removeItem(values.pop())
|
||
}
|
||
self.showInput();
|
||
self.positionDropdown();
|
||
self.refreshOptions(true);
|
||
// select previous option
|
||
if (option_select) {
|
||
$option_select = self.getOption(option_select);
|
||
if ($option_select.length) {
|
||
self.setActiveOption($option_select)
|
||
}
|
||
}
|
||
return true
|
||
},
|
||
/**
|
||
* Selects the previous / next item (depending
|
||
* on the `direction` argument).
|
||
*
|
||
* > 0 - right
|
||
* < 0 - left
|
||
*
|
||
* @param {int} direction
|
||
* @param {object} e (optional)
|
||
*/
|
||
advanceSelection: function (direction, e) {
|
||
var tail, selection, idx, valueLength, cursorAtEdge, $tail;
|
||
var self = this;
|
||
if (direction === 0)
|
||
return;
|
||
if (self.rtl)
|
||
direction *= -1;
|
||
tail = direction > 0 ? 'last' : 'first';
|
||
selection = getSelection(self.$control_input[0]);
|
||
if (self.isFocused && !self.isInputHidden) {
|
||
valueLength = self.$control_input.val().length;
|
||
cursorAtEdge = direction < 0 ? selection.start === 0 && selection.length === 0 : selection.start === valueLength;
|
||
if (cursorAtEdge && !valueLength) {
|
||
self.advanceCaret(direction, e)
|
||
}
|
||
} else {
|
||
$tail = self.$control.children('.active:' + tail);
|
||
if ($tail.length) {
|
||
idx = self.$control.children(':not(input)').index($tail);
|
||
self.setActiveItem(null);
|
||
self.setCaret(direction > 0 ? idx + 1 : idx)
|
||
}
|
||
}
|
||
},
|
||
/**
|
||
* Moves the caret left / right.
|
||
*
|
||
* @param {int} direction
|
||
* @param {object} e (optional)
|
||
*/
|
||
advanceCaret: function (direction, e) {
|
||
var self = this, fn, $adj;
|
||
if (direction === 0)
|
||
return;
|
||
fn = direction > 0 ? 'next' : 'prev';
|
||
if (self.isShiftDown) {
|
||
$adj = self.$control_input[fn]();
|
||
if ($adj.length) {
|
||
self.hideInput();
|
||
self.setActiveItem($adj);
|
||
e && e.preventDefault()
|
||
}
|
||
} else {
|
||
self.setCaret(self.caretPos + direction)
|
||
}
|
||
},
|
||
/**
|
||
* Moves the caret to the specified index.
|
||
*
|
||
* @param {int} i
|
||
*/
|
||
setCaret: function (i) {
|
||
var self = this;
|
||
if (self.settings.mode === 'single') {
|
||
i = self.items.length
|
||
} else {
|
||
i = Math.max(0, Math.min(self.items.length, i))
|
||
}
|
||
if (!self.isPending) {
|
||
// the input must be moved by leaving it in place and moving the
|
||
// siblings, due to the fact that focus cannot be restored once lost
|
||
// on mobile webkit devices
|
||
var j, n, fn, $children, $child;
|
||
$children = self.$control.children(':not(input)');
|
||
for (j = 0, n = $children.length; j < n; j++) {
|
||
$child = $($children[j]).detach();
|
||
if (j < i) {
|
||
self.$control_input.before($child)
|
||
} else {
|
||
self.$control.append($child)
|
||
}
|
||
}
|
||
}
|
||
self.caretPos = i
|
||
},
|
||
/**
|
||
* Disables user input on the control. Used while
|
||
* items are being asynchronously created.
|
||
*/
|
||
lock: function () {
|
||
this.close();
|
||
this.isLocked = true;
|
||
this.refreshState()
|
||
},
|
||
/**
|
||
* Re-enables user input on the control.
|
||
*/
|
||
unlock: function () {
|
||
this.isLocked = false;
|
||
this.refreshState()
|
||
},
|
||
/**
|
||
* Disables user input on the control completely.
|
||
* While disabled, it cannot receive focus.
|
||
*/
|
||
disable: function () {
|
||
var self = this;
|
||
self.$input.prop('disabled', true);
|
||
self.$control_input.prop('disabled', true).prop('tabindex', -1);
|
||
self.isDisabled = true;
|
||
self.lock()
|
||
},
|
||
/**
|
||
* Enables the control so that it can respond
|
||
* to focus and user input.
|
||
*/
|
||
enable: function () {
|
||
var self = this;
|
||
self.$input.prop('disabled', false);
|
||
self.$control_input.prop('disabled', false).prop('tabindex', self.tabIndex);
|
||
self.isDisabled = false;
|
||
self.unlock()
|
||
},
|
||
/**
|
||
* Completely destroys the control and
|
||
* unbinds all event listeners so that it can
|
||
* be garbage collected.
|
||
*/
|
||
destroy: function () {
|
||
var self = this;
|
||
var eventNS = self.eventNS;
|
||
var revertSettings = self.revertSettings;
|
||
self.trigger('destroy');
|
||
self.off();
|
||
self.$wrapper.remove();
|
||
self.$dropdown.remove();
|
||
self.$input.html('').append(revertSettings.$children).removeAttr('tabindex').removeClass('selectized').attr({ tabindex: revertSettings.tabindex }).show();
|
||
self.$control_input.removeData('grow');
|
||
self.$input.removeData('selectize');
|
||
$(window).off(eventNS);
|
||
$(document).off(eventNS);
|
||
$(document.body).off(eventNS);
|
||
delete self.$input[0].selectize
|
||
},
|
||
/**
|
||
* A helper method for rendering "item" and
|
||
* "option" templates, given the data.
|
||
*
|
||
* @param {string} templateName
|
||
* @param {object} data
|
||
* @returns {string}
|
||
*/
|
||
render: function (templateName, data) {
|
||
var value, id, label;
|
||
var html = '';
|
||
var cache = false;
|
||
var self = this;
|
||
var regex_tag = /^[\t \r\n]*<([a-z][a-z0-9\-_]*(?:\:[a-z][a-z0-9\-_]*)?)/i;
|
||
if (templateName === 'option' || templateName === 'item') {
|
||
value = hash_key(data[self.settings.valueField]);
|
||
cache = !!value
|
||
}
|
||
// pull markup from cache if it exists
|
||
if (cache) {
|
||
if (!isset(self.renderCache[templateName])) {
|
||
self.renderCache[templateName] = {}
|
||
}
|
||
if (self.renderCache[templateName].hasOwnProperty(value)) {
|
||
return self.renderCache[templateName][value]
|
||
}
|
||
}
|
||
// render markup
|
||
html = self.settings.render[templateName].apply(this, [
|
||
data,
|
||
escape_html
|
||
]);
|
||
// add mandatory attributes
|
||
if (templateName === 'option' || templateName === 'option_create') {
|
||
html = html.replace(regex_tag, '<$1 data-selectable')
|
||
}
|
||
if (templateName === 'optgroup') {
|
||
id = data[self.settings.optgroupValueField] || '';
|
||
html = html.replace(regex_tag, '<$1 data-group="' + escape_replace(escape_html(id)) + '"')
|
||
}
|
||
if (templateName === 'option' || templateName === 'item') {
|
||
html = html.replace(regex_tag, '<$1 data-value="' + escape_replace(escape_html(value || '')) + '"')
|
||
}
|
||
// update cache
|
||
if (cache) {
|
||
self.renderCache[templateName][value] = html
|
||
}
|
||
return html
|
||
},
|
||
/**
|
||
* Clears the render cache for a template. If
|
||
* no template is given, clears all render
|
||
* caches.
|
||
*
|
||
* @param {string} templateName
|
||
*/
|
||
clearCache: function (templateName) {
|
||
var self = this;
|
||
if (typeof templateName === 'undefined') {
|
||
self.renderCache = {}
|
||
} else {
|
||
delete self.renderCache[templateName]
|
||
}
|
||
},
|
||
/**
|
||
* Determines whether or not to display the
|
||
* create item prompt, given a user input.
|
||
*
|
||
* @param {string} input
|
||
* @return {boolean}
|
||
*/
|
||
canCreate: function (input) {
|
||
var self = this;
|
||
if (!self.settings.create)
|
||
return false;
|
||
var filter = self.settings.createFilter;
|
||
return input.length && (typeof filter !== 'function' || filter.apply(self, [input])) && (typeof filter !== 'string' || new RegExp(filter).test(input)) && (!(filter instanceof RegExp) || filter.test(input))
|
||
}
|
||
});
|
||
Selectize.count = 0;
|
||
Selectize.defaults = {
|
||
options: [],
|
||
optgroups: [],
|
||
plugins: [],
|
||
delimiter: ',',
|
||
splitOn: null,
|
||
// regexp or string for splitting up values from a paste command
|
||
persist: true,
|
||
diacritics: true,
|
||
create: false,
|
||
createOnBlur: false,
|
||
createFilter: null,
|
||
highlight: true,
|
||
openOnFocus: true,
|
||
maxOptions: 1000,
|
||
maxItems: null,
|
||
hideSelected: null,
|
||
addPrecedence: false,
|
||
selectOnTab: false,
|
||
preload: false,
|
||
allowEmptyOption: false,
|
||
closeAfterSelect: false,
|
||
scrollDuration: 60,
|
||
loadThrottle: 300,
|
||
loadingClass: 'loading',
|
||
dataAttr: 'data-data',
|
||
optgroupField: 'optgroup',
|
||
valueField: 'value',
|
||
labelField: 'text',
|
||
optgroupLabelField: 'label',
|
||
optgroupValueField: 'value',
|
||
lockOptgroupOrder: false,
|
||
sortField: '$order',
|
||
searchField: ['text'],
|
||
searchConjunction: 'and',
|
||
mode: null,
|
||
wrapperClass: 'selectize-control',
|
||
inputClass: 'selectize-input',
|
||
dropdownClass: 'selectize-dropdown',
|
||
dropdownContentClass: 'selectize-dropdown-content',
|
||
dropdownParent: null,
|
||
copyClassesToDropdown: true,
|
||
/*
|
||
load : null, // function(query, callback) { ... }
|
||
score : null, // function(search) { ... }
|
||
onInitialize : null, // function() { ... }
|
||
onChange : null, // function(value) { ... }
|
||
onItemAdd : null, // function(value, $item) { ... }
|
||
onItemRemove : null, // function(value) { ... }
|
||
onClear : null, // function() { ... }
|
||
onOptionAdd : null, // function(value, data) { ... }
|
||
onOptionRemove : null, // function(value) { ... }
|
||
onOptionClear : null, // function() { ... }
|
||
onOptionGroupAdd : null, // function(id, data) { ... }
|
||
onOptionGroupRemove : null, // function(id) { ... }
|
||
onOptionGroupClear : null, // function() { ... }
|
||
onDropdownOpen : null, // function($dropdown) { ... }
|
||
onDropdownClose : null, // function($dropdown) { ... }
|
||
onType : null, // function(str) { ... }
|
||
onDelete : null, // function(values) { ... }
|
||
*/
|
||
render: {}
|
||
};
|
||
$.fn.selectize = function (settings_user) {
|
||
var defaults = $.fn.selectize.defaults;
|
||
var settings = $.extend({}, defaults, settings_user);
|
||
var attr_data = settings.dataAttr;
|
||
var field_label = settings.labelField;
|
||
var field_value = settings.valueField;
|
||
var field_optgroup = settings.optgroupField;
|
||
var field_optgroup_label = settings.optgroupLabelField;
|
||
var field_optgroup_value = settings.optgroupValueField;
|
||
/**
|
||
* Initializes selectize from a <input type="text"> element.
|
||
*
|
||
* @param {object} $input
|
||
* @param {object} settings_element
|
||
*/
|
||
var init_textbox = function ($input, settings_element) {
|
||
var i, n, values, option;
|
||
var data_raw = $input.attr(attr_data);
|
||
if (!data_raw) {
|
||
var value = $.trim($input.val() || '');
|
||
if (!settings.allowEmptyOption && !value.length)
|
||
return;
|
||
values = value.split(settings.delimiter);
|
||
for (i = 0, n = values.length; i < n; i++) {
|
||
option = {};
|
||
option[field_label] = values[i];
|
||
option[field_value] = values[i];
|
||
settings_element.options.push(option)
|
||
}
|
||
settings_element.items = values
|
||
} else {
|
||
settings_element.options = JSON.parse(data_raw);
|
||
for (i = 0, n = settings_element.options.length; i < n; i++) {
|
||
settings_element.items.push(settings_element.options[i][field_value])
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Initializes selectize from a <select> element.
|
||
*
|
||
* @param {object} $input
|
||
* @param {object} settings_element
|
||
*/
|
||
var init_select = function ($input, settings_element) {
|
||
var i, n, tagName, $children, order = 0;
|
||
var options = settings_element.options;
|
||
var optionsMap = {};
|
||
var readData = function ($el) {
|
||
var data = attr_data && $el.attr(attr_data);
|
||
if (typeof data === 'string' && data.length) {
|
||
return JSON.parse(data)
|
||
}
|
||
return null
|
||
};
|
||
var addOption = function ($option, group) {
|
||
$option = $($option);
|
||
var value = hash_key($option.attr('value'));
|
||
if (!value && !settings.allowEmptyOption)
|
||
return;
|
||
// if the option already exists, it's probably been
|
||
// duplicated in another optgroup. in this case, push
|
||
// the current group to the "optgroup" property on the
|
||
// existing option so that it's rendered in both places.
|
||
if (optionsMap.hasOwnProperty(value)) {
|
||
if (group) {
|
||
var arr = optionsMap[value][field_optgroup];
|
||
if (!arr) {
|
||
optionsMap[value][field_optgroup] = group
|
||
} else if (!$.isArray(arr)) {
|
||
optionsMap[value][field_optgroup] = [
|
||
arr,
|
||
group
|
||
]
|
||
} else {
|
||
arr.push(group)
|
||
}
|
||
}
|
||
return
|
||
}
|
||
var option = readData($option) || {};
|
||
option[field_label] = option[field_label] || $option.text();
|
||
option[field_value] = option[field_value] || value;
|
||
option[field_optgroup] = option[field_optgroup] || group;
|
||
optionsMap[value] = option;
|
||
options.push(option);
|
||
if ($option.is(':selected')) {
|
||
settings_element.items.push(value)
|
||
}
|
||
};
|
||
var addGroup = function ($optgroup) {
|
||
var i, n, id, optgroup, $options;
|
||
$optgroup = $($optgroup);
|
||
id = $optgroup.attr('label');
|
||
if (id) {
|
||
optgroup = readData($optgroup) || {};
|
||
optgroup[field_optgroup_label] = id;
|
||
optgroup[field_optgroup_value] = id;
|
||
settings_element.optgroups.push(optgroup)
|
||
}
|
||
$options = $('option', $optgroup);
|
||
for (i = 0, n = $options.length; i < n; i++) {
|
||
addOption($options[i], id)
|
||
}
|
||
};
|
||
settings_element.maxItems = $input.attr('multiple') ? null : 1;
|
||
$children = $input.children();
|
||
for (i = 0, n = $children.length; i < n; i++) {
|
||
tagName = $children[i].tagName.toLowerCase();
|
||
if (tagName === 'optgroup') {
|
||
addGroup($children[i])
|
||
} else if (tagName === 'option') {
|
||
addOption($children[i])
|
||
}
|
||
}
|
||
};
|
||
return this.each(function () {
|
||
if (this.selectize)
|
||
return;
|
||
var instance;
|
||
var $input = $(this);
|
||
var tag_name = this.tagName.toLowerCase();
|
||
var placeholder = $input.attr('placeholder') || $input.attr('data-placeholder');
|
||
if (!placeholder && !settings.allowEmptyOption) {
|
||
placeholder = $input.children('option[value=""]').text()
|
||
}
|
||
var settings_element = {
|
||
'placeholder': placeholder,
|
||
'options': [],
|
||
'optgroups': [],
|
||
'items': []
|
||
};
|
||
if (tag_name === 'select') {
|
||
init_select($input, settings_element)
|
||
} else {
|
||
init_textbox($input, settings_element)
|
||
}
|
||
instance = new Selectize($input, $.extend(true, {}, defaults, settings_element, settings_user))
|
||
})
|
||
};
|
||
$.fn.selectize.defaults = Selectize.defaults;
|
||
$.fn.selectize.support = { validity: SUPPORTS_VALIDITY_API };
|
||
Selectize.define('drag_drop', function (options) {
|
||
if (!$.fn.sortable)
|
||
throw new Error('The "drag_drop" plugin requires jQuery UI "sortable".');
|
||
if (this.settings.mode !== 'multi')
|
||
return;
|
||
var self = this;
|
||
self.lock = function () {
|
||
var original = self.lock;
|
||
return function () {
|
||
var sortable = self.$control.data('sortable');
|
||
if (sortable)
|
||
sortable.disable();
|
||
return original.apply(self, arguments)
|
||
}
|
||
}();
|
||
self.unlock = function () {
|
||
var original = self.unlock;
|
||
return function () {
|
||
var sortable = self.$control.data('sortable');
|
||
if (sortable)
|
||
sortable.enable();
|
||
return original.apply(self, arguments)
|
||
}
|
||
}();
|
||
self.setup = function () {
|
||
var original = self.setup;
|
||
return function () {
|
||
original.apply(this, arguments);
|
||
var $control = self.$control.sortable({
|
||
items: '[data-value]',
|
||
forcePlaceholderSize: true,
|
||
disabled: self.isLocked,
|
||
start: function (e, ui) {
|
||
ui.placeholder.css('width', ui.helper.css('width'));
|
||
$control.css({ overflow: 'visible' })
|
||
},
|
||
stop: function () {
|
||
$control.css({ overflow: 'hidden' });
|
||
var active = self.$activeItems ? self.$activeItems.slice() : null;
|
||
var values = [];
|
||
$control.children('[data-value]').each(function () {
|
||
values.push($(this).attr('data-value'))
|
||
});
|
||
self.setValue(values);
|
||
self.setActiveItem(active)
|
||
}
|
||
})
|
||
}
|
||
}()
|
||
});
|
||
Selectize.define('dropdown_header', function (options) {
|
||
var self = this;
|
||
options = $.extend({
|
||
title: 'Untitled',
|
||
headerClass: 'selectize-dropdown-header',
|
||
titleRowClass: 'selectize-dropdown-header-title',
|
||
labelClass: 'selectize-dropdown-header-label',
|
||
closeClass: 'selectize-dropdown-header-close',
|
||
html: function (data) {
|
||
return '<div class="' + data.headerClass + '">' + '<div class="' + data.titleRowClass + '">' + '<span class="' + data.labelClass + '">' + data.title + '</span>' + '<a href="javascript:void(0)" class="' + data.closeClass + '">×</a>' + '</div>' + '</div>'
|
||
}
|
||
}, options);
|
||
self.setup = function () {
|
||
var original = self.setup;
|
||
return function () {
|
||
original.apply(self, arguments);
|
||
self.$dropdown_header = $(options.html(options));
|
||
self.$dropdown.prepend(self.$dropdown_header)
|
||
}
|
||
}()
|
||
});
|
||
Selectize.define('optgroup_columns', function (options) {
|
||
var self = this;
|
||
options = $.extend({
|
||
equalizeWidth: true,
|
||
equalizeHeight: true
|
||
}, options);
|
||
this.getAdjacentOption = function ($option, direction) {
|
||
var $options = $option.closest('[data-group]').find('[data-selectable]');
|
||
var index = $options.index($option) + direction;
|
||
return index >= 0 && index < $options.length ? $options.eq(index) : $()
|
||
};
|
||
this.onKeyDown = function () {
|
||
var original = self.onKeyDown;
|
||
return function (e) {
|
||
var index, $option, $options, $optgroup;
|
||
if (this.isOpen && (e.keyCode === KEY_LEFT || e.keyCode === KEY_RIGHT)) {
|
||
self.ignoreHover = true;
|
||
$optgroup = this.$activeOption.closest('[data-group]');
|
||
index = $optgroup.find('[data-selectable]').index(this.$activeOption);
|
||
if (e.keyCode === KEY_LEFT) {
|
||
$optgroup = $optgroup.prev('[data-group]')
|
||
} else {
|
||
$optgroup = $optgroup.next('[data-group]')
|
||
}
|
||
$options = $optgroup.find('[data-selectable]');
|
||
$option = $options.eq(Math.min($options.length - 1, index));
|
||
if ($option.length) {
|
||
this.setActiveOption($option)
|
||
}
|
||
return
|
||
}
|
||
return original.apply(this, arguments)
|
||
}
|
||
}();
|
||
var getScrollbarWidth = function () {
|
||
var div;
|
||
var width = getScrollbarWidth.width;
|
||
var doc = document;
|
||
if (typeof width === 'undefined') {
|
||
div = doc.createElement('div');
|
||
div.innerHTML = '<div style="width:50px;height:50px;position:absolute;left:-50px;top:-50px;overflow:auto;"><div style="width:1px;height:100px;"></div></div>';
|
||
div = div.firstChild;
|
||
doc.body.appendChild(div);
|
||
width = getScrollbarWidth.width = div.offsetWidth - div.clientWidth;
|
||
doc.body.removeChild(div)
|
||
}
|
||
return width
|
||
};
|
||
var equalizeSizes = function () {
|
||
var i, n, height_max, width, width_last, width_parent, $optgroups;
|
||
$optgroups = $('[data-group]', self.$dropdown_content);
|
||
n = $optgroups.length;
|
||
if (!n || !self.$dropdown_content.width())
|
||
return;
|
||
if (options.equalizeHeight) {
|
||
height_max = 0;
|
||
for (i = 0; i < n; i++) {
|
||
height_max = Math.max(height_max, $optgroups.eq(i).height())
|
||
}
|
||
$optgroups.css({ height: height_max })
|
||
}
|
||
if (options.equalizeWidth) {
|
||
width_parent = self.$dropdown_content.innerWidth() - getScrollbarWidth();
|
||
width = Math.round(width_parent / n);
|
||
$optgroups.css({ width: width });
|
||
if (n > 1) {
|
||
width_last = width_parent - width * (n - 1);
|
||
$optgroups.eq(n - 1).css({ width: width_last })
|
||
}
|
||
}
|
||
};
|
||
if (options.equalizeHeight || options.equalizeWidth) {
|
||
hook.after(this, 'positionDropdown', equalizeSizes);
|
||
hook.after(this, 'refreshOptions', equalizeSizes)
|
||
}
|
||
});
|
||
Selectize.define('remove_button', function (options) {
|
||
if (this.settings.mode === 'single')
|
||
return;
|
||
options = $.extend({
|
||
label: '×',
|
||
title: 'Remove',
|
||
className: 'remove',
|
||
append: true
|
||
}, options);
|
||
var self = this;
|
||
var html = '<a href="javascript:void(0)" class="' + options.className + '" tabindex="-1" title="' + escape_html(options.title) + '">' + options.label + '</a>';
|
||
/**
|
||
* Appends an element as a child (with raw HTML).
|
||
*
|
||
* @param {string} html_container
|
||
* @param {string} html_element
|
||
* @return {string}
|
||
*/
|
||
var append = function (html_container, html_element) {
|
||
var pos = html_container.search(/(<\/[^>]+>\s*)$/);
|
||
return html_container.substring(0, pos) + html_element + html_container.substring(pos)
|
||
};
|
||
this.setup = function () {
|
||
var original = self.setup;
|
||
return function () {
|
||
// override the item rendering method to add the button to each
|
||
if (options.append) {
|
||
var render_item = self.settings.render.item;
|
||
self.settings.render.item = function (data) {
|
||
return append(render_item.apply(this, arguments), html)
|
||
}
|
||
}
|
||
original.apply(this, arguments);
|
||
// add event listener
|
||
this.$control.on('click', '.' + options.className, function (e) {
|
||
e.preventDefault();
|
||
if (self.isLocked)
|
||
return;
|
||
var $item = $(e.currentTarget).parent();
|
||
self.setActiveItem($item);
|
||
if (self.deleteSelection()) {
|
||
self.setCaret(self.items.length)
|
||
}
|
||
})
|
||
}
|
||
}()
|
||
});
|
||
Selectize.define('restore_on_backspace', function (options) {
|
||
var self = this;
|
||
options.text = options.text || function (option) {
|
||
return option[this.settings.labelField]
|
||
};
|
||
this.onKeyDown = function () {
|
||
var original = self.onKeyDown;
|
||
return function (e) {
|
||
var index, option;
|
||
if (e.keyCode === KEY_BACKSPACE && this.$control_input.val() === '' && !this.$activeItems.length) {
|
||
index = this.caretPos - 1;
|
||
if (index >= 0 && index < this.items.length) {
|
||
option = this.options[this.items[index]];
|
||
if (this.deleteSelection(e)) {
|
||
this.setTextboxValue(options.text.apply(this, [option]));
|
||
this.refreshOptions(true)
|
||
}
|
||
e.preventDefault();
|
||
return
|
||
}
|
||
}
|
||
return original.apply(this, arguments)
|
||
}
|
||
}()
|
||
});
|
||
return Selectize
|
||
}))
|
||
});
|
||
// source: node_modules/sifter/sifter.js
|
||
require.define('sifter/sifter', function (module, exports, __dirname, __filename, process) {
|
||
/**
|
||
* sifter.js
|
||
* Copyright (c) 2013 Brian Reavis & contributors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
|
||
* file except in compliance with the License. You may obtain a copy of the License at:
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software distributed under
|
||
* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
|
||
* ANY KIND, either express or implied. See the License for the specific language
|
||
* governing permissions and limitations under the License.
|
||
*
|
||
* @author Brian Reavis <[email protected]>
|
||
*/
|
||
(function (root, factory) {
|
||
if (typeof define === 'function' && define.amd) {
|
||
define(factory)
|
||
} else if (typeof exports === 'object') {
|
||
module.exports = factory()
|
||
} else {
|
||
root.Sifter = factory()
|
||
}
|
||
}(this, function () {
|
||
/**
|
||
* Textually searches arrays and hashes of objects
|
||
* by property (or multiple properties). Designed
|
||
* specifically for autocomplete.
|
||
*
|
||
* @constructor
|
||
* @param {array|object} items
|
||
* @param {object} items
|
||
*/
|
||
var Sifter = function (items, settings) {
|
||
this.items = items;
|
||
this.settings = settings || { diacritics: true }
|
||
};
|
||
/**
|
||
* Splits a search string into an array of individual
|
||
* regexps to be used to match results.
|
||
*
|
||
* @param {string} query
|
||
* @returns {array}
|
||
*/
|
||
Sifter.prototype.tokenize = function (query) {
|
||
query = trim(String(query || '').toLowerCase());
|
||
if (!query || !query.length)
|
||
return [];
|
||
var i, n, regex, letter;
|
||
var tokens = [];
|
||
var words = query.split(/ +/);
|
||
for (i = 0, n = words.length; i < n; i++) {
|
||
regex = escape_regex(words[i]);
|
||
if (this.settings.diacritics) {
|
||
for (letter in DIACRITICS) {
|
||
if (DIACRITICS.hasOwnProperty(letter)) {
|
||
regex = regex.replace(new RegExp(letter, 'g'), DIACRITICS[letter])
|
||
}
|
||
}
|
||
}
|
||
tokens.push({
|
||
string: words[i],
|
||
regex: new RegExp(regex, 'i')
|
||
})
|
||
}
|
||
return tokens
|
||
};
|
||
/**
|
||
* Iterates over arrays and hashes.
|
||
*
|
||
* ```
|
||
* this.iterator(this.items, function(item, id) {
|
||
* // invoked for each item
|
||
* });
|
||
* ```
|
||
*
|
||
* @param {array|object} object
|
||
*/
|
||
Sifter.prototype.iterator = function (object, callback) {
|
||
var iterator;
|
||
if (is_array(object)) {
|
||
iterator = Array.prototype.forEach || function (callback) {
|
||
for (var i = 0, n = this.length; i < n; i++) {
|
||
callback(this[i], i, this)
|
||
}
|
||
}
|
||
} else {
|
||
iterator = function (callback) {
|
||
for (var key in this) {
|
||
if (this.hasOwnProperty(key)) {
|
||
callback(this[key], key, this)
|
||
}
|
||
}
|
||
}
|
||
}
|
||
iterator.apply(object, [callback])
|
||
};
|
||
/**
|
||
* Returns a function to be used to score individual results.
|
||
*
|
||
* Good matches will have a higher score than poor matches.
|
||
* If an item is not a match, 0 will be returned by the function.
|
||
*
|
||
* @param {object|string} search
|
||
* @param {object} options (optional)
|
||
* @returns {function}
|
||
*/
|
||
Sifter.prototype.getScoreFunction = function (search, options) {
|
||
var self, fields, tokens, token_count;
|
||
self = this;
|
||
search = self.prepareSearch(search, options);
|
||
tokens = search.tokens;
|
||
fields = search.options.fields;
|
||
token_count = tokens.length;
|
||
/**
|
||
* Calculates how close of a match the
|
||
* given value is against a search token.
|
||
*
|
||
* @param {mixed} value
|
||
* @param {object} token
|
||
* @return {number}
|
||
*/
|
||
var scoreValue = function (value, token) {
|
||
var score, pos;
|
||
if (!value)
|
||
return 0;
|
||
value = String(value || '');
|
||
pos = value.search(token.regex);
|
||
if (pos === -1)
|
||
return 0;
|
||
score = token.string.length / value.length;
|
||
if (pos === 0)
|
||
score += 0.5;
|
||
return score
|
||
};
|
||
/**
|
||
* Calculates the score of an object
|
||
* against the search query.
|
||
*
|
||
* @param {object} token
|
||
* @param {object} data
|
||
* @return {number}
|
||
*/
|
||
var scoreObject = function () {
|
||
var field_count = fields.length;
|
||
if (!field_count) {
|
||
return function () {
|
||
return 0
|
||
}
|
||
}
|
||
if (field_count === 1) {
|
||
return function (token, data) {
|
||
return scoreValue(data[fields[0]], token)
|
||
}
|
||
}
|
||
return function (token, data) {
|
||
for (var i = 0, sum = 0; i < field_count; i++) {
|
||
sum += scoreValue(data[fields[i]], token)
|
||
}
|
||
return sum / field_count
|
||
}
|
||
}();
|
||
if (!token_count) {
|
||
return function () {
|
||
return 0
|
||
}
|
||
}
|
||
if (token_count === 1) {
|
||
return function (data) {
|
||
return scoreObject(tokens[0], data)
|
||
}
|
||
}
|
||
if (search.options.conjunction === 'and') {
|
||
return function (data) {
|
||
var score;
|
||
for (var i = 0, sum = 0; i < token_count; i++) {
|
||
score = scoreObject(tokens[i], data);
|
||
if (score <= 0)
|
||
return 0;
|
||
sum += score
|
||
}
|
||
return sum / token_count
|
||
}
|
||
} else {
|
||
return function (data) {
|
||
for (var i = 0, sum = 0; i < token_count; i++) {
|
||
sum += scoreObject(tokens[i], data)
|
||
}
|
||
return sum / token_count
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Returns a function that can be used to compare two
|
||
* results, for sorting purposes. If no sorting should
|
||
* be performed, `null` will be returned.
|
||
*
|
||
* @param {string|object} search
|
||
* @param {object} options
|
||
* @return function(a,b)
|
||
*/
|
||
Sifter.prototype.getSortFunction = function (search, options) {
|
||
var i, n, self, field, fields, fields_count, multiplier, multipliers, get_field, implicit_score, sort;
|
||
self = this;
|
||
search = self.prepareSearch(search, options);
|
||
sort = !search.query && options.sort_empty || options.sort;
|
||
/**
|
||
* Fetches the specified sort field value
|
||
* from a search result item.
|
||
*
|
||
* @param {string} name
|
||
* @param {object} result
|
||
* @return {mixed}
|
||
*/
|
||
get_field = function (name, result) {
|
||
if (name === '$score')
|
||
return result.score;
|
||
return self.items[result.id][name]
|
||
};
|
||
// parse options
|
||
fields = [];
|
||
if (sort) {
|
||
for (i = 0, n = sort.length; i < n; i++) {
|
||
if (search.query || sort[i].field !== '$score') {
|
||
fields.push(sort[i])
|
||
}
|
||
}
|
||
}
|
||
// the "$score" field is implied to be the primary
|
||
// sort field, unless it's manually specified
|
||
if (search.query) {
|
||
implicit_score = true;
|
||
for (i = 0, n = fields.length; i < n; i++) {
|
||
if (fields[i].field === '$score') {
|
||
implicit_score = false;
|
||
break
|
||
}
|
||
}
|
||
if (implicit_score) {
|
||
fields.unshift({
|
||
field: '$score',
|
||
direction: 'desc'
|
||
})
|
||
}
|
||
} else {
|
||
for (i = 0, n = fields.length; i < n; i++) {
|
||
if (fields[i].field === '$score') {
|
||
fields.splice(i, 1);
|
||
break
|
||
}
|
||
}
|
||
}
|
||
multipliers = [];
|
||
for (i = 0, n = fields.length; i < n; i++) {
|
||
multipliers.push(fields[i].direction === 'desc' ? -1 : 1)
|
||
}
|
||
// build function
|
||
fields_count = fields.length;
|
||
if (!fields_count) {
|
||
return null
|
||
} else if (fields_count === 1) {
|
||
field = fields[0].field;
|
||
multiplier = multipliers[0];
|
||
return function (a, b) {
|
||
return multiplier * cmp(get_field(field, a), get_field(field, b))
|
||
}
|
||
} else {
|
||
return function (a, b) {
|
||
var i, result, a_value, b_value, field;
|
||
for (i = 0; i < fields_count; i++) {
|
||
field = fields[i].field;
|
||
result = multipliers[i] * cmp(get_field(field, a), get_field(field, b));
|
||
if (result)
|
||
return result
|
||
}
|
||
return 0
|
||
}
|
||
}
|
||
};
|
||
/**
|
||
* Parses a search query and returns an object
|
||
* with tokens and fields ready to be populated
|
||
* with results.
|
||
*
|
||
* @param {string} query
|
||
* @param {object} options
|
||
* @returns {object}
|
||
*/
|
||
Sifter.prototype.prepareSearch = function (query, options) {
|
||
if (typeof query === 'object')
|
||
return query;
|
||
options = extend({}, options);
|
||
var option_fields = options.fields;
|
||
var option_sort = options.sort;
|
||
var option_sort_empty = options.sort_empty;
|
||
if (option_fields && !is_array(option_fields))
|
||
options.fields = [option_fields];
|
||
if (option_sort && !is_array(option_sort))
|
||
options.sort = [option_sort];
|
||
if (option_sort_empty && !is_array(option_sort_empty))
|
||
options.sort_empty = [option_sort_empty];
|
||
return {
|
||
options: options,
|
||
query: String(query || '').toLowerCase(),
|
||
tokens: this.tokenize(query),
|
||
total: 0,
|
||
items: []
|
||
}
|
||
};
|
||
/**
|
||
* Searches through all items and returns a sorted array of matches.
|
||
*
|
||
* The `options` parameter can contain:
|
||
*
|
||
* - fields {string|array}
|
||
* - sort {array}
|
||
* - score {function}
|
||
* - filter {bool}
|
||
* - limit {integer}
|
||
*
|
||
* Returns an object containing:
|
||
*
|
||
* - options {object}
|
||
* - query {string}
|
||
* - tokens {array}
|
||
* - total {int}
|
||
* - items {array}
|
||
*
|
||
* @param {string} query
|
||
* @param {object} options
|
||
* @returns {object}
|
||
*/
|
||
Sifter.prototype.search = function (query, options) {
|
||
var self = this, value, score, search, calculateScore;
|
||
var fn_sort;
|
||
var fn_score;
|
||
search = this.prepareSearch(query, options);
|
||
options = search.options;
|
||
query = search.query;
|
||
// generate result scoring function
|
||
fn_score = options.score || self.getScoreFunction(search);
|
||
// perform search and sort
|
||
if (query.length) {
|
||
self.iterator(self.items, function (item, id) {
|
||
score = fn_score(item);
|
||
if (options.filter === false || score > 0) {
|
||
search.items.push({
|
||
'score': score,
|
||
'id': id
|
||
})
|
||
}
|
||
})
|
||
} else {
|
||
self.iterator(self.items, function (item, id) {
|
||
search.items.push({
|
||
'score': 1,
|
||
'id': id
|
||
})
|
||
})
|
||
}
|
||
fn_sort = self.getSortFunction(search, options);
|
||
if (fn_sort)
|
||
search.items.sort(fn_sort);
|
||
// apply limits
|
||
search.total = search.items.length;
|
||
if (typeof options.limit === 'number') {
|
||
search.items = search.items.slice(0, options.limit)
|
||
}
|
||
return search
|
||
};
|
||
// utilities
|
||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||
var cmp = function (a, b) {
|
||
if (typeof a === 'number' && typeof b === 'number') {
|
||
return a > b ? 1 : a < b ? -1 : 0
|
||
}
|
||
a = asciifold(String(a || ''));
|
||
b = asciifold(String(b || ''));
|
||
if (a > b)
|
||
return 1;
|
||
if (b > a)
|
||
return -1;
|
||
return 0
|
||
};
|
||
var extend = function (a, b) {
|
||
var i, n, k, object;
|
||
for (i = 1, n = arguments.length; i < n; i++) {
|
||
object = arguments[i];
|
||
if (!object)
|
||
continue;
|
||
for (k in object) {
|
||
if (object.hasOwnProperty(k)) {
|
||
a[k] = object[k]
|
||
}
|
||
}
|
||
}
|
||
return a
|
||
};
|
||
var trim = function (str) {
|
||
return (str + '').replace(/^\s+|\s+$|/g, '')
|
||
};
|
||
var escape_regex = function (str) {
|
||
return (str + '').replace(/([.?*+^$[\]\\(){}|-])/g, '\\$1')
|
||
};
|
||
var is_array = Array.isArray || typeof $ !== 'undefined' && $.isArray || function (object) {
|
||
return Object.prototype.toString.call(object) === '[object Array]'
|
||
};
|
||
var DIACRITICS = {
|
||
'a': '[aÀÁÂÃÄÅàáâãäåĀāąĄ]',
|
||
'c': '[cÇçćĆčČ]',
|
||
'd': '[dđĐďĎð]',
|
||
'e': '[eÈÉÊËèéêëěĚĒēęĘ]',
|
||
'i': '[iÌÍÎÏìíîïĪī]',
|
||
'l': '[lłŁ]',
|
||
'n': '[nÑñňŇńŃ]',
|
||
'o': '[oÒÓÔÕÕÖØòóôõöøŌō]',
|
||
'r': '[rřŘ]',
|
||
's': '[sŠšśŚ]',
|
||
't': '[tťŤ]',
|
||
'u': '[uÙÚÛÜùúûüůŮŪū]',
|
||
'y': '[yŸÿýÝ]',
|
||
'z': '[zŽžżŻźŹ]'
|
||
};
|
||
var asciifold = function () {
|
||
var i, n, k, chunk;
|
||
var foreignletters = '';
|
||
var lookup = {};
|
||
for (k in DIACRITICS) {
|
||
if (DIACRITICS.hasOwnProperty(k)) {
|
||
chunk = DIACRITICS[k].substring(2, DIACRITICS[k].length - 1);
|
||
foreignletters += chunk;
|
||
for (i = 0, n = chunk.length; i < n; i++) {
|
||
lookup[chunk.charAt(i)] = k
|
||
}
|
||
}
|
||
}
|
||
var regexp = new RegExp('[' + foreignletters + ']', 'g');
|
||
return function (str) {
|
||
return str.replace(regexp, function (foreignletter) {
|
||
return lookup[foreignletter]
|
||
}).toLowerCase()
|
||
}
|
||
}();
|
||
// export
|
||
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
|
||
return Sifter
|
||
}))
|
||
});
|
||
// source: node_modules/microplugin/src/microplugin.js
|
||
require.define('microplugin/src/microplugin', function (module, exports, __dirname, __filename, process) {
|
||
/**
|
||
* microplugin.js
|
||
* Copyright (c) 2013 Brian Reavis & contributors
|
||
*
|
||
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this
|
||
* file except in compliance with the License. You may obtain a copy of the License at:
|
||
* http://www.apache.org/licenses/LICENSE-2.0
|
||
*
|
||
* Unless required by applicable law or agreed to in writing, software distributed under
|
||
* the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF
|
||
* ANY KIND, either express or implied. See the License for the specific language
|
||
* governing permissions and limitations under the License.
|
||
*
|
||
* @author Brian Reavis <[email protected]>
|
||
*/
|
||
(function (root, factory) {
|
||
if (typeof define === 'function' && define.amd) {
|
||
define(factory)
|
||
} else if (typeof exports === 'object') {
|
||
module.exports = factory()
|
||
} else {
|
||
root.MicroPlugin = factory()
|
||
}
|
||
}(this, function () {
|
||
var MicroPlugin = {};
|
||
MicroPlugin.mixin = function (Interface) {
|
||
Interface.plugins = {};
|
||
/**
|
||
* Initializes the listed plugins (with options).
|
||
* Acceptable formats:
|
||
*
|
||
* List (without options):
|
||
* ['a', 'b', 'c']
|
||
*
|
||
* List (with options):
|
||
* [{'name': 'a', options: {}}, {'name': 'b', options: {}}]
|
||
*
|
||
* Hash (with options):
|
||
* {'a': { ... }, 'b': { ... }, 'c': { ... }}
|
||
*
|
||
* @param {mixed} plugins
|
||
*/
|
||
Interface.prototype.initializePlugins = function (plugins) {
|
||
var i, n, key;
|
||
var self = this;
|
||
var queue = [];
|
||
self.plugins = {
|
||
names: [],
|
||
settings: {},
|
||
requested: {},
|
||
loaded: {}
|
||
};
|
||
if (utils.isArray(plugins)) {
|
||
for (i = 0, n = plugins.length; i < n; i++) {
|
||
if (typeof plugins[i] === 'string') {
|
||
queue.push(plugins[i])
|
||
} else {
|
||
self.plugins.settings[plugins[i].name] = plugins[i].options;
|
||
queue.push(plugins[i].name)
|
||
}
|
||
}
|
||
} else if (plugins) {
|
||
for (key in plugins) {
|
||
if (plugins.hasOwnProperty(key)) {
|
||
self.plugins.settings[key] = plugins[key];
|
||
queue.push(key)
|
||
}
|
||
}
|
||
}
|
||
while (queue.length) {
|
||
self.require(queue.shift())
|
||
}
|
||
};
|
||
Interface.prototype.loadPlugin = function (name) {
|
||
var self = this;
|
||
var plugins = self.plugins;
|
||
var plugin = Interface.plugins[name];
|
||
if (!Interface.plugins.hasOwnProperty(name)) {
|
||
throw new Error('Unable to find "' + name + '" plugin')
|
||
}
|
||
plugins.requested[name] = true;
|
||
plugins.loaded[name] = plugin.fn.apply(self, [self.plugins.settings[name] || {}]);
|
||
plugins.names.push(name)
|
||
};
|
||
/**
|
||
* Initializes a plugin.
|
||
*
|
||
* @param {string} name
|
||
*/
|
||
Interface.prototype.require = function (name) {
|
||
var self = this;
|
||
var plugins = self.plugins;
|
||
if (!self.plugins.loaded.hasOwnProperty(name)) {
|
||
if (plugins.requested[name]) {
|
||
throw new Error('Plugin has circular dependency ("' + name + '")')
|
||
}
|
||
self.loadPlugin(name)
|
||
}
|
||
return plugins.loaded[name]
|
||
};
|
||
/**
|
||
* Registers a plugin.
|
||
*
|
||
* @param {string} name
|
||
* @param {function} fn
|
||
*/
|
||
Interface.define = function (name, fn) {
|
||
Interface.plugins[name] = {
|
||
'name': name,
|
||
'fn': fn
|
||
}
|
||
}
|
||
};
|
||
var utils = {
|
||
isArray: Array.isArray || function (vArg) {
|
||
return Object.prototype.toString.call(vArg) === '[object Array]'
|
||
}
|
||
};
|
||
return MicroPlugin
|
||
}))
|
||
});
|
||
// source: src/page.coffee
|
||
require.define('./page', function (module, exports, __dirname, __filename, process) {
|
||
var Page, RiotPage, riot, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
Page = require('daisho-sdk/lib').Page;
|
||
riot = require('crowdcontrol/lib').riot.riot;
|
||
module.exports = RiotPage = function (superClass) {
|
||
extend(RiotPage, superClass);
|
||
function RiotPage() {
|
||
return RiotPage.__super__.constructor.apply(this, arguments)
|
||
}
|
||
RiotPage.prototype.tagEl = 'tag';
|
||
RiotPage.prototype.opts = null;
|
||
RiotPage.prototype.load = function (opts) {
|
||
this.opts = opts != null ? opts : {}
|
||
};
|
||
RiotPage.prototype.render = function () {
|
||
var el;
|
||
el = document.createElement(this.tag);
|
||
this.el.appendChild(el);
|
||
this.tagEl = riot.mount(el, this.tag, this.opts)[0];
|
||
return this.tagEl.update()
|
||
};
|
||
RiotPage.prototype.unload = function () {
|
||
return this.tagEl.unmount()
|
||
};
|
||
return RiotPage
|
||
}(Page)
|
||
});
|
||
// source: node_modules/daisho-sdk/lib/index.js
|
||
require.define('daisho-sdk/lib', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
module.exports = {
|
||
Page: require('daisho-sdk/lib/page'),
|
||
Module: require('daisho-sdk/lib/module')
|
||
} //# sourceMappingURL=index.js.map
|
||
});
|
||
// source: node_modules/daisho-sdk/lib/page.js
|
||
require.define('daisho-sdk/lib/page', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Page;
|
||
module.exports = Page = function () {
|
||
Page.prototype.el = null;
|
||
Page.prototype.module = null;
|
||
function Page(el, module1) {
|
||
this.el = el;
|
||
this.module = module1
|
||
}
|
||
Page.prototype.load = function (opts) {
|
||
this.opts = opts != null ? opts : {}
|
||
};
|
||
Page.prototype.render = function () {
|
||
};
|
||
Page.prototype.unload = function () {
|
||
};
|
||
Page.prototype.annotations = function () {
|
||
};
|
||
return Page
|
||
}() //# sourceMappingURL=page.js.map
|
||
});
|
||
// source: node_modules/daisho-sdk/lib/module.js
|
||
require.define('daisho-sdk/lib/module', function (module, exports, __dirname, __filename, process) {
|
||
// Generated by CoffeeScript 1.10.0
|
||
var Module;
|
||
module.exports = Module = function () {
|
||
Module.prototype.json = null;
|
||
function Module() {
|
||
}
|
||
Module.prototype.load = function (opts) {
|
||
this.opts = opts != null ? opts : {}
|
||
};
|
||
Module.prototype.unload = function () {
|
||
};
|
||
return Module
|
||
}() //# sourceMappingURL=module.js.map
|
||
});
|
||
// source: src/forms/index.coffee
|
||
require.define('./forms', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = {
|
||
TableRow: require('./forms/table-row'),
|
||
register: function () {
|
||
return this.TableRow.register()
|
||
}
|
||
}
|
||
});
|
||
// source: src/forms/table-row.coffee
|
||
require.define('./forms/table-row', function (module, exports, __dirname, __filename, process) {
|
||
var CrowdControl, TableRow, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
CrowdControl = require('crowdcontrol/lib');
|
||
module.exports = TableRow = function (superClass) {
|
||
extend(TableRow, superClass);
|
||
function TableRow() {
|
||
return TableRow.__super__.constructor.apply(this, arguments)
|
||
}
|
||
TableRow.prototype.tag = 'daisho-table-row';
|
||
TableRow.prototype.configs = null;
|
||
TableRow.prototype.tableData = null;
|
||
TableRow.prototype.data = null;
|
||
TableRow.prototype.html = require('./Users/dtai/work/hanzo/daisho-riot/templates/table-row');
|
||
TableRow.prototype.init = function () {
|
||
if (this.configs == null) {
|
||
this.configs = this.parent.configs
|
||
}
|
||
if (this.tableData == null) {
|
||
this.tableData = this.parent.tableData
|
||
}
|
||
return TableRow.__super__.init.apply(this, arguments)
|
||
};
|
||
return TableRow
|
||
}(CrowdControl.Views.Form)
|
||
});
|
||
// source: templates/table-row.html
|
||
require.define('./Users/dtai/work/hanzo/daisho-riot/templates/table-row', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = '<div each="{ column, i in tableData.get(\'columns\') }">\n <daisho-poly-control lookup="{ column.id }" tag="{ column.tag }"></daisho-poly-control>\n</div>\n\n'
|
||
});
|
||
// source: src/widgets/index.coffee
|
||
require.define('./widgets', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = {
|
||
Table: require('./widgets/table'),
|
||
TableControls: require('./widgets/table-controls'),
|
||
Menu: require('./widgets/menu'),
|
||
TableFilterMenu: require('./widgets/table-filter-menu'),
|
||
register: function () {
|
||
this.Table.register();
|
||
this.TableControls.register();
|
||
this.Menu.register();
|
||
return this.TableFilterMenu.register()
|
||
}
|
||
}
|
||
});
|
||
// source: src/widgets/table.coffee
|
||
require.define('./widgets/table', function (module, exports, __dirname, __filename, process) {
|
||
var CrowdControl, Table, refer, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
CrowdControl = require('crowdcontrol/lib');
|
||
refer = require('referential/lib');
|
||
module.exports = Table = function (superClass) {
|
||
extend(Table, superClass);
|
||
function Table() {
|
||
return Table.__super__.constructor.apply(this, arguments)
|
||
}
|
||
Table.prototype.tag = 'daisho-table-widget';
|
||
Table.prototype.nameSinglular = 'Thing';
|
||
Table.prototype.namePlural = 'Things';
|
||
Table.prototype.configs = [];
|
||
Table.prototype.data = refer({});
|
||
Table.prototype.html = require('./Users/dtai/work/hanzo/daisho-riot/templates/table-widget');
|
||
return Table
|
||
}(CrowdControl.Views.View)
|
||
});
|
||
// source: templates/table-widget.html
|
||
require.define('./Users/dtai/work/hanzo/daisho-riot/templates/table-widget', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = '<div class="table-head">\n <div class="table-row">\n <div each="{ column, i in data.get(\'columns\') }">{ column.name }</div>\n </div>\n</div>\n<div class="table-body">\n <daisho-table-row class="table-row" each="{ item, i in data.get(\'items\') }" table-data="{ this.parent.data }" data="{ this.parent.data.ref(\'items.\' + i) }" config="{ this.parent.config }"></daisho-table-row>\n</div>\n\n'
|
||
});
|
||
// source: src/widgets/table-controls.coffee
|
||
require.define('./widgets/table-controls', function (module, exports, __dirname, __filename, process) {
|
||
var $, CrowdControl, TableControls, refer, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
CrowdControl = require('crowdcontrol/lib');
|
||
refer = require('referential/lib');
|
||
$ = require('jquery/dist/jquery');
|
||
module.exports = TableControls = function (superClass) {
|
||
extend(TableControls, superClass);
|
||
function TableControls() {
|
||
return TableControls.__super__.constructor.apply(this, arguments)
|
||
}
|
||
TableControls.prototype.tag = 'daisho-table-controls-widget';
|
||
TableControls.prototype.configs = [];
|
||
TableControls.prototype.data = null;
|
||
TableControls.prototype.filterData = null;
|
||
TableControls.prototype.html = require('./Users/dtai/work/hanzo/daisho-riot/templates/table-controls-widget');
|
||
TableControls.prototype.init = function () {
|
||
if (this.data == null) {
|
||
this.data = refer({ filter: '' })
|
||
}
|
||
if (this.data.get('filter') == null) {
|
||
this.data.set('filter', '')
|
||
}
|
||
if (this.filterData == null) {
|
||
this.filterData = refer({ options: [] })
|
||
}
|
||
return TableControls.__super__.init.apply(this, arguments)
|
||
};
|
||
TableControls.prototype.countWords = function () {
|
||
var count;
|
||
count = this.data.get('count');
|
||
if (count === 1) {
|
||
return count + ' ' + this.nameSingular
|
||
} else {
|
||
return count + ' ' + this.namePlural
|
||
}
|
||
};
|
||
TableControls.prototype.sortWords = function () {
|
||
var column, columns, i, len, lsort, sort;
|
||
sort = this.data.get('sort');
|
||
if (sort[0] === '-') {
|
||
sort = sort.substr(1)
|
||
}
|
||
lsort = sort.toLowerCase();
|
||
columns = this.data.get('columns');
|
||
for (i = 0, len = columns.length; i < len; i++) {
|
||
column = columns[i];
|
||
if (column.id.toLowerCase() === lsort) {
|
||
return column.name
|
||
}
|
||
}
|
||
return sort
|
||
};
|
||
TableControls.prototype.resetMenus = function (event) {
|
||
var $toggle, value;
|
||
if (event != null) {
|
||
$toggle = $(this.root).find('#' + event.target.htmlFor);
|
||
value = $toggle.prop('checked')
|
||
}
|
||
$(this.root).find('.menu-toggle').prop('checked', false);
|
||
if (event != null) {
|
||
return $toggle.prop('checked', !value)
|
||
}
|
||
};
|
||
TableControls.prototype.ignore = function (event) {
|
||
event.stopPropagation();
|
||
event.preventDefault();
|
||
return false
|
||
};
|
||
return TableControls
|
||
}(CrowdControl.Views.View)
|
||
});
|
||
// source: templates/table-controls-widget.html
|
||
require.define('./Users/dtai/work/hanzo/daisho-riot/templates/table-controls-widget', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = '<div class="table-filter-summary">\n <span class="table-filter-count">\n { countWords() }\n </span>\n <span>sorted by</span>\n <span class="table-filter-sort">\n { sortWords() }\n </span>\n</div>\n<input id="table-column-button" class="menu-toggle" type="checkbox">\n<label class="table-filter-option button" for="table-column-button">\n Columns\n</label>\n<input id="table-filter-button" class="menu-toggle" type="checkbox">\n<label class="table-filter-option button" for="table-filter-button" onclick="{ resetMenus }">\n <span>Filters</span>\n <div class="menu" onclick="{ ignore }">\n <div class="menu-title">Filters</div>\n<daisho-table-filter-menu-widget configs="{ configs }" data="{ data }" filter-data="{ filterData }" filter-placeholder="Find a filter"></daisho-table-filter-menu-widget>\n </div>\n</label>\n'
|
||
});
|
||
// source: src/widgets/menu.coffee
|
||
require.define('./widgets/menu', function (module, exports, __dirname, __filename, process) {
|
||
var CrowdControl, Menu, filter, refer, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
CrowdControl = require('crowdcontrol/lib');
|
||
refer = require('referential/lib');
|
||
filter = require('./utils/menu').filter;
|
||
module.exports = Menu = function (superClass) {
|
||
extend(Menu, superClass);
|
||
function Menu() {
|
||
return Menu.__super__.constructor.apply(this, arguments)
|
||
}
|
||
Menu.prototype.tag = 'daisho-menu-widget';
|
||
Menu.prototype.configs = { filter: null };
|
||
Menu.prototype.filter = true;
|
||
Menu.prototype.filterPlaceholder = 'Type Something';
|
||
Menu.prototype.options = [];
|
||
Menu.prototype.filterData = null;
|
||
Menu.prototype.data = null;
|
||
Menu.prototype.html = require('./Users/dtai/work/hanzo/daisho-riot/templates/menu-widget');
|
||
Menu.prototype.init = function () {
|
||
if (this.data == null) {
|
||
this.data = refer({ filter: '' })
|
||
}
|
||
if (this.filterData == null) {
|
||
this.filterData = refer({ options: [] })
|
||
}
|
||
Menu.__super__.init.apply(this, arguments);
|
||
this.on('update', function (_this) {
|
||
return function () {
|
||
return _this.options = filter(_this.filterData.get('options'), _this.data.get('filter'))
|
||
}
|
||
}(this));
|
||
return this.inputs.filter.on('change', function (_this) {
|
||
return function () {
|
||
return _this.update()
|
||
}
|
||
}(this))
|
||
};
|
||
Menu.prototype.noResults = function () {
|
||
return this.options.length === 0
|
||
};
|
||
return Menu
|
||
}(CrowdControl.Views.Form)
|
||
});
|
||
// source: src/utils/menu.coffee
|
||
require.define('./utils/menu', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = {
|
||
filter: function (options, filter) {
|
||
var i, len, option, ret;
|
||
ret = [];
|
||
for (i = 0, len = options.length; i < len; i++) {
|
||
option = options[i];
|
||
if (option.name.toLowerCase().indexOf(filter.toLowerCase()) > -1) {
|
||
ret.push(option)
|
||
}
|
||
}
|
||
return ret
|
||
}
|
||
}
|
||
});
|
||
// source: templates/menu-widget.html
|
||
require.define('./Users/dtai/work/hanzo/daisho-riot/templates/menu-widget', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = '<daisho-inline-text-control lookup="filter" if="{ filter }" placeholder="{ filterPlaceholder }" realtime="true"></daisho-inline-text-control>\n<ul>\n <li each="{ option, i in options }" onclick="{ option.action }">{ option.name }</li>\n <li class="no-results" if="{ noResults() }">No Search Results</li>\n</ul>\n'
|
||
});
|
||
// source: src/widgets/table-filter-menu.coffee
|
||
require.define('./widgets/table-filter-menu', function (module, exports, __dirname, __filename, process) {
|
||
var Menu, TableFilterMenu, extend = function (child, parent) {
|
||
for (var key in parent) {
|
||
if (hasProp.call(parent, key))
|
||
child[key] = parent[key]
|
||
}
|
||
function ctor() {
|
||
this.constructor = child
|
||
}
|
||
ctor.prototype = parent.prototype;
|
||
child.prototype = new ctor;
|
||
child.__super__ = parent.prototype;
|
||
return child
|
||
}, hasProp = {}.hasOwnProperty;
|
||
Menu = require('./widgets/menu');
|
||
module.exports = TableFilterMenu = function (superClass) {
|
||
extend(TableFilterMenu, superClass);
|
||
function TableFilterMenu() {
|
||
return TableFilterMenu.__super__.constructor.apply(this, arguments)
|
||
}
|
||
TableFilterMenu.prototype.tag = 'daisho-table-filter-menu-widget';
|
||
TableFilterMenu.prototype.configs = { filter: null };
|
||
TableFilterMenu.prototype.data = null;
|
||
TableFilterMenu.prototype.filterData = null;
|
||
TableFilterMenu.prototype.html = require('./Users/dtai/work/hanzo/daisho-riot/templates/table-filter-menu-widget');
|
||
TableFilterMenu.prototype.init = function () {
|
||
return TableFilterMenu.__super__.init.apply(this, arguments)
|
||
};
|
||
return TableFilterMenu
|
||
}(Menu)
|
||
});
|
||
// source: templates/table-filter-menu-widget.html
|
||
require.define('./Users/dtai/work/hanzo/daisho-riot/templates/table-filter-menu-widget', function (module, exports, __dirname, __filename, process) {
|
||
module.exports = '<daisho-inline-text-control lookup="filter" if="{ filter }" placeholder="{ filterPlaceholder }" realtime="true"></daisho-inline-text-control>\n<ul>\n <li each="{ option, i in options }" onclick="{ option.action }">\n <daisho-poly-control lookup="{ option.id }" tag="{ option.tag }" opts-override="{ option.options }"></daisho-poly-control>\n </li>\n <li class="no-results" if="{ noResults() }">No Search Results</li>\n</ul>\n'
|
||
});
|
||
// source: src/index.coffee
|
||
require.define('./index', function (module, exports, __dirname, __filename, process) {
|
||
var Controls;
|
||
Controls = require('./controls');
|
||
if (typeof window !== 'undefined' && window !== null) {
|
||
window.$ = require('jquery/dist/jquery');
|
||
require('selectize/dist/js/selectize')
|
||
}
|
||
module.exports = {
|
||
RiotPage: require('./page'),
|
||
Events: require('./events'),
|
||
Controls: require('./controls'),
|
||
Forms: require('./forms'),
|
||
Widgets: require('./widgets'),
|
||
register: function (m) {
|
||
this.Controls.register(m);
|
||
this.Forms.register();
|
||
return this.Widgets.register()
|
||
}
|
||
}
|
||
});
|
||
require('./index')
|
||
}.call(this, this))//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["controls/index.coffee","controls/poly.coffee","node_modules/crowdcontrol/lib/index.js","node_modules/crowdcontrol/lib/riot.js","node_modules/crowdcontrol/lib/views/index.js","node_modules/crowdcontrol/lib/views/form.js","node_modules/crowdcontrol/lib/views/view.js","node_modules/object-assign/index.js","node_modules/is-function/index.js","node_modules/crowdcontrol/lib/views/inputify.js","node_modules/broken/lib/index.js","node_modules/zousan/zousan-min.js","node_modules/referential/lib/index.js","node_modules/referential/lib/refer.js","node_modules/referential/lib/ref.js","node_modules/node.extend/index.js","node_modules/node.extend/lib/extend.js","node_modules/is/index.js","node_modules/is-array/index.js","node_modules/is-number/index.js","node_modules/kind-of/index.js","node_modules/is-buffer/index.js","node_modules/is-object/index.js","node_modules/is-string/index.js","node_modules/promise-settle/index.js","node_modules/promise-settle/lib/promise-settle.js","node_modules/crowdcontrol/lib/views/input.js","controls/control.coffee","events.coffee","node_modules/jquery/dist/jquery.js","controls/text.coffee","Users/dtai/work/hanzo/daisho-riot/templates/text.html","controls/inline-text.coffee","utils/placeholder.coffee","Users/dtai/work/hanzo/daisho-riot/templates/inline-text.html","controls/static-text.coffee","controls/static-date.coffee","node_modules/moment/moment.js","controls/static-ago.coffee","node_modules/selectize/dist/js/selectize.js","node_modules/sifter/sifter.js","node_modules/microplugin/src/microplugin.js","page.coffee","node_modules/daisho-sdk/lib/index.js","node_modules/daisho-sdk/lib/page.js","node_modules/daisho-sdk/lib/module.js","forms/index.coffee","forms/table-row.coffee","Users/dtai/work/hanzo/daisho-riot/templates/table-row.html","widgets/index.coffee","widgets/table.coffee","Users/dtai/work/hanzo/daisho-riot/templates/table-widget.html","widgets/table-controls.coffee","Users/dtai/work/hanzo/daisho-riot/templates/table-controls-widget.html","widgets/menu.coffee","utils/menu.coffee","Users/dtai/work/hanzo/daisho-riot/templates/menu-widget.html","widgets/table-filter-menu.coffee","Users/dtai/work/hanzo/daisho-riot/templates/table-filter-menu-widget.html","index.coffee"],"names":["require","module","exports","Control","Text","InlineText","StaticText","StaticDate","StaticAgo","register","m","riot","tag","opts","el","tagEl","optsOverride","document","createElement","root","appendChild","parent","mount","update","CrowdControl","r","Views","tags","start","i","len","ref","results","length","push","window","Crowdstart","Crowdcontrol","set","Form","Input","View","Promise","inputify","observable","settle","extend","child","key","hasProp","call","ctor","constructor","prototype","__super__","hasOwnProperty","superClass","apply","arguments","configs","inputs","data","initInputs","input","name","results1","init","submit","pRef","ps","trigger","p","then","_this","result","isFulfilled","_submit","collapsePrototype","isFunction","objectAssign","setPrototypeOf","mixinProperties","setProtoOf","obj","proto","__proto__","prop","Object","Array","collapse","parentProto","getPrototypeOf","html","css","attrs","events","newProto","beforeInit","fn","handler","k","ref1","self","v","oldFn","on","propIsEnumerable","propertyIsEnumerable","toObject","val","undefined","TypeError","assign","target","source","from","to","symbols","s","getOwnPropertySymbols","toString","string","setTimeout","alert","confirm","prompt","isRef","refer","o","config","fn1","middleware","middlewareFn","validate","pair","resolve","get","j","len1","PromiseInspection","suppressUncaughtRejectionError","arg","state","value","reason","isRejected","reflect","promise","reject","err","promises","all","map","callback","cb","error","t","e","n","y","c","u","f","splice","MutationObserver","observe","attributes","setAttribute","setImmediate","console","log","stack","l","a","timeout","Error","Zousan","soon","global","Ref","method","wrapper","clone","isArray","isNumber","isObject","isString","_value","key1","_cache","_mutate","index","prev","next","props","String","split","shift","is","deep","options","src","copy","copy_is_array","hash","array","version","objProto","owns","toStr","symbolValueOf","Symbol","valueOf","isActualNaN","NON_HOST_TYPES","number","base64Regex","hexRegex","type","defined","empty","equal","other","getTime","hosted","host","instance","nil","undef","args","isStandardArguments","isOldArguments","arraylike","object","callee","bool","isFinite","Boolean","Number","date","element","HTMLElement","nodeType","isAlert","infinite","Infinity","decimal","divisibleBy","isDividendInfinite","isDivisorInfinite","isNonZeroNumber","integer","maximum","others","minimum","nan","even","odd","ge","gt","le","lt","within","finish","isAnyInfinite","setInterval","regexp","base64","test","hex","symbol","str","typeOf","num","isBuffer","kindOf","Function","RegExp","Date","Buffer","_isBuffer","x","strValue","tryStringObject","strClass","hasToStringTag","toStringTag","promiseResults","promiseResult","catch","returns","bind","throws","errorMessage","errorHtml","getValue","event","change","clearError","message","changed","$","Events","scrolling","lookup","trim","DOMException","animate","scrollTop","offset","top","height","complete","duration","ChangeFailed","Change","ChangeSuccess","FilterChange","factory","w","noGlobal","arr","slice","concat","indexOf","class2type","hasOwn","support","jQuery","selector","context","rtrim","rmsPrefix","rdashAlpha","fcamelCase","letter","toUpperCase","jquery","toArray","pushStack","elems","ret","merge","prevObject","each","elem","first","eq","last","end","sort","copyIsArray","isPlainObject","expando","Math","random","replace","isReady","msg","noop","isWindow","isNumeric","realStringObj","parseFloat","isEmptyObject","globalEval","code","script","indirect","eval","text","head","parentNode","removeChild","camelCase","nodeName","toLowerCase","isArrayLike","makeArray","inArray","second","grep","invert","callbackInverse","matches","callbackExpect","guid","proxy","tmp","now","iterator","Sizzle","Expr","getText","isXML","tokenize","compile","select","outermostContext","sortInput","hasDuplicate","setDocument","docElem","documentIsHTML","rbuggyQSA","rbuggyMatches","contains","preferredDoc","dirruns","done","classCache","createCache","tokenCache","compilerCache","sortOrder","b","MAX_NEGATIVE","pop","push_native","list","booleans","whitespace","identifier","pseudos","rwhitespace","rcomma","rcombinators","rattributeQuotes","rpseudo","ridentifier","matchExpr","rinputs","rheader","rnative","rquickExpr","rsibling","rescape","runescape","funescape","_","escaped","escapedWhitespace","high","fromCharCode","unloadHandler","childNodes","els","seed","nid","nidselect","match","groups","newSelector","newContext","ownerDocument","exec","getElementById","id","getElementsByTagName","getElementsByClassName","qsa","getAttribute","toSelector","join","testContext","querySelectorAll","qsaError","removeAttribute","keys","cache","cacheLength","markFunction","assert","div","addHandle","attrHandle","siblingCheck","cur","diff","sourceIndex","nextSibling","createInputPseudo","createButtonPseudo","createPositionalPseudo","argument","matchIndexes","documentElement","node","hasCompare","doc","defaultView","addEventListener","attachEvent","className","createComment","getById","getElementsByName","find","filter","attrId","getAttributeNode","innerHTML","matchesSelector","webkitMatchesSelector","mozMatchesSelector","oMatchesSelector","msMatchesSelector","disconnectedMatch","compareDocumentPosition","adown","bup","compare","sortDetached","aup","ap","bp","unshift","expr","elements","attr","specified","uniqueSort","duplicates","detectDuplicates","sortStable","textContent","firstChild","nodeValue","selectors","createPseudo","relative","dir","preFilter","excess","unquoted","nodeNameSelector","pattern","operator","check","what","simple","forward","ofType","xml","uniqueCache","outerCache","nodeIndex","useCache","lastChild","uniqueID","pseudo","setFilters","idx","matched","matcher","unmatched","innerText","lang","elemLang","location","activeElement","hasFocus","href","tabIndex","disabled","checked","selected","selectedIndex","radio","checkbox","file","password","image","reset","filters","parseOnly","tokens","soFar","preFilters","cached","addCombinator","combinator","base","checkNonElements","doneName","oldCache","newCache","elementMatcher","matchers","multipleContexts","contexts","condense","newUnmatched","mapped","setMatcher","postFilter","postFinder","postSelector","temp","preMap","postMap","preexisting","matcherIn","matcherOut","matcherFromTokens","checkContext","leadingRelative","implicitRelative","matchContext","matchAnyContext","matcherFromGroupMatchers","elementMatchers","setMatchers","bySet","byElement","superMatcher","outermost","matchedCount","setMatched","contextBackup","dirrunsUnique","token","compiled","div1","defaultValue","unique","isXMLDoc","until","truncate","siblings","rneedsContext","needsContext","rsingleTag","risSimple","winnow","qualifier","not","rootjQuery","parseHTML","ready","rparentsprev","guaranteedUnique","children","contents","has","targets","closest","pos","prevAll","add","addBack","sibling","parents","parentsUntil","nextAll","nextUntil","prevUntil","contentDocument","reverse","rnotwhite","createOptions","flag","Callbacks","firing","memory","fired","locked","queue","firingIndex","fire","once","stopOnFalse","remove","disable","lock","fireWith","Deferred","func","tuples","always","deferred","fail","fns","newDefer","tuple","returned","progress","notify","pipe","stateString","when","subordinate","resolveValues","remaining","updateFunc","values","progressValues","notifyWith","resolveWith","progressContexts","resolveContexts","readyList","readyWait","holdReady","hold","wait","triggerHandler","off","completed","removeEventListener","readyState","doScroll","access","chainable","emptyGet","raw","bulk","acceptData","owner","Data","uid","initial","defineProperty","writable","configurable","stored","camel","hasData","dataPriv","dataUser","rbrace","rmultiDash","dataAttr","parseJSON","removeData","_data","_removeData","camelKey","dequeue","startLength","hooks","_queueHooks","stop","setter","clearQueue","count","defer","pnum","rcssNum","cssExpand","isHidden","adjustCSS","valueParts","tween","adjusted","scale","maxIterations","currentValue","unit","cssNumber","initialInUnit","style","rcheckableType","rtagName","rscriptType","wrapMap","option","thead","col","tr","td","_default","optgroup","tbody","tfoot","colgroup","caption","th","getAll","setGlobalEval","refElements","rhtml","buildFragment","scripts","selection","ignored","wrap","fragment","createDocumentFragment","nodes","createTextNode","htmlPrefilter","checkClone","cloneNode","noCloneChecked","rkeyEvent","rmouseEvent","rtypenamespace","returnTrue","returnFalse","safeActiveElement","types","one","origFn","handleObjIn","eventHandle","handleObj","special","handlers","namespaces","origType","elemData","handle","triggered","dispatch","delegateType","bindType","namespace","delegateCount","setup","mappedTypes","origCount","teardown","removeEvent","fix","handlerQueue","delegateTarget","preDispatch","isPropagationStopped","currentTarget","isImmediatePropagationStopped","rnamespace","preventDefault","stopPropagation","postDispatch","sel","isNaN","button","fixHooks","keyHooks","original","which","charCode","keyCode","mouseHooks","eventDoc","body","pageX","clientX","scrollLeft","clientLeft","pageY","clientY","clientTop","originalEvent","fixHook","Event","load","noBubble","focus","blur","click","beforeunload","returnValue","isDefaultPrevented","defaultPrevented","timeStamp","stopImmediatePropagation","mouseenter","mouseleave","pointerenter","pointerleave","orig","related","relatedTarget","rxhtmlTag","rnoInnerhtml","rchecked","rscriptTypeMasked","rcleanScript","manipulationTarget","content","disableScript","restoreScript","cloneCopyEvent","dest","pdataOld","pdataCur","udataOld","udataCur","fixInput","domManip","collection","hasScripts","iNoClone","_evalUrl","keepData","cleanData","dataAndEvents","deepDataAndEvents","srcElements","destElements","inPage","detach","append","prepend","insertBefore","before","after","replaceWith","replaceChild","appendTo","prependTo","insertAfter","replaceAll","insert","iframe","elemdisplay","HTML","BODY","actualDisplay","display","defaultDisplay","write","close","rmargin","rnumnonpx","getStyles","view","opener","getComputedStyle","swap","old","pixelPositionVal","boxSizingReliableVal","pixelMarginRightVal","reliableMarginLeftVal","container","backgroundClip","clearCloneStyle","cssText","computeStyleTests","divStyle","marginLeft","width","marginRight","pixelPosition","boxSizingReliable","pixelMarginRight","reliableMarginLeft","reliableMarginRight","marginDiv","curCSS","computed","minWidth","maxWidth","getPropertyValue","addGetHookIf","conditionFn","hookFn","rdisplayswap","cssShow","position","visibility","cssNormalTransform","letterSpacing","fontWeight","cssPrefixes","emptyStyle","vendorPropName","capName","setPositiveNumber","subtract","max","augmentWidthOrHeight","extra","isBorderBox","styles","getWidthOrHeight","valueIsBorderBox","offsetWidth","offsetHeight","msFullscreenElement","getClientRects","round","getBoundingClientRect","showHide","show","hidden","cssHooks","opacity","cssProps","origName","left","margin","padding","border","prefix","suffix","expand","expanded","parts","hide","toggle","Tween","easing","propHooks","run","percent","eased","step","fx","linear","swing","cos","PI","fxNow","timerId","rfxtypes","rrun","createFxNow","genFx","includeWidth","createTween","animation","Animation","tweeners","defaultPrefilter","oldfire","checkDisplay","anim","dataShow","unqueued","overflow","overflowX","overflowY","propFilter","specialEasing","properties","stopped","prefilters","tick","currentTime","startTime","tweens","originalProperties","originalOptions","gotoEnd","rejectWith","timer","tweener","prefilter","speed","opt","speeds","fadeTo","optall","doAnimation","stopQueue","timers","cssFn","slideDown","slideUp","slideToggle","fadeIn","fadeOut","fadeToggle","interval","clearInterval","slow","fast","delay","time","clearTimeout","checkOn","optSelected","optDisabled","radioValue","boolHook","removeAttr","nType","attrHooks","propName","attrNames","propFix","getter","rfocusable","rclickable","removeProp","tabindex","parseInt","rclass","getClass","addClass","classes","curValue","clazz","finalValue","removeClass","toggleClass","stateVal","classNames","hasClass","rreturn","rspaces","valHooks","optionSet","rfocusMorph","onlyHandlers","bubbleType","ontype","eventPath","isTrigger","parentWindow","simulate","isSimulated","hover","fnOver","fnOut","focusin","attaches","nonce","rquery","JSON","parse","parseXML","DOMParser","parseFromString","rhash","rts","rheaders","rlocalProtocol","rnoContent","rprotocol","transports","allTypes","originAnchor","addToPrefiltersOrTransports","structure","dataTypeExpression","dataType","dataTypes","inspectPrefiltersOrTransports","jqXHR","inspected","seekingTransport","inspect","prefilterOrFactory","dataTypeOrTransport","ajaxExtend","flatOptions","ajaxSettings","ajaxHandleResponses","responses","ct","finalDataType","firstDataType","mimeType","getResponseHeader","converters","ajaxConvert","response","isSuccess","conv2","current","conv","responseFields","dataFilter","active","lastModified","etag","url","isLocal","protocol","processData","async","contentType","accepts","json","ajaxSetup","settings","ajaxPrefilter","ajaxTransport","ajax","transport","cacheURL","responseHeadersString","responseHeaders","timeoutTimer","urlAnchor","fireGlobals","callbackContext","globalEventContext","completeDeferred","statusCode","requestHeaders","requestHeadersNames","strAbort","getAllResponseHeaders","setRequestHeader","lname","overrideMimeType","status","abort","statusText","finalText","success","crossDomain","param","traditional","hasContent","ifModified","headers","beforeSend","send","nativeStatusText","modified","getJSON","getScript","wrapAll","firstElementChild","wrapInner","unwrap","visible","r20","rbracket","rCRLF","rsubmitterTypes","rsubmittable","buildParams","encodeURIComponent","serialize","serializeArray","xhr","XMLHttpRequest","xhrSuccessStatus","xhrSupported","cors","errorCallback","open","username","xhrFields","onload","onerror","onabort","onreadystatechange","responseType","responseText","binary","charset","scriptCharset","evt","oldCallbacks","rjsonp","jsonp","jsonpCallback","originalSettings","callbackName","overwritten","responseContainer","jsonProp","keepScripts","parsed","_load","params","animated","getWindow","setOffset","curPosition","curLeft","curCSSTop","curTop","curOffset","curCSSLeft","calculatePosition","curElem","using","win","box","pageYOffset","pageXOffset","offsetParent","parentOffset","scrollTo","Height","Width","defaultExtra","funcName","unbind","delegate","undelegate","size","andSelf","define","amd","_jQuery","_$","noConflict","realtime","keyup","placeholder","label","formElement","hidePlaceholderOnFocus","unfocusOnAnElement","srcElement","_placeholdered","moment","format","hookCallback","utils_hooks__hooks","setHookCallback","isDate","res","hasOwnProp","create_utc__createUTC","locale","strict","createLocalOrUTC","utc","defaultParsingFlags","unusedTokens","unusedInput","charsLeftOver","nullInput","invalidMonth","invalidFormat","userInvalidated","iso","getParsingFlags","_pf","valid__isValid","_isValid","flags","_d","invalidWeekday","_strict","bigHour","valid__createInvalid","NaN","isUndefined","momentProperties","copyConfig","_isAMomentObject","_i","_f","_l","_tzm","_isUTC","_offset","_locale","updateInProgress","Moment","updateOffset","isMoment","absFloor","ceil","floor","toInt","argumentForCoercion","coercedNumber","compareArrays","array1","array2","dontConvert","min","lengthDiff","abs","diffs","warn","suppressDeprecationWarnings","deprecate","firstTime","deprecations","deprecateSimple","locale_set__set","_config","_ordinalParseLenient","_ordinalParse","mergeConfigs","parentConfig","childConfig","Locale","locales","globalLocale","normalizeLocale","chooseLocale","names","loadLocale","oldLocale","_abbr","locale_locales__getSetGlobalLocale","locale_locales__getLocale","defineLocale","abbr","parentLocale","updateLocale","locale_locales__listLocales","aliases","addUnitAlias","shorthand","lowerCase","normalizeUnits","units","normalizeObjectUnits","inputObject","normalizedInput","normalizedProp","makeGetSet","keepTime","get_set__set","get_set__get","mom","isValid","getSet","zeroFill","targetLength","forceSign","absNumber","zerosToFill","sign","pow","substr","formattingTokens","localFormattingTokens","formatFunctions","formatTokenFunctions","addFormatToken","padded","ordinal","localeData","removeFormattingTokens","makeFormatFunction","output","formatMoment","invalidDate","expandFormat","replaceLongDateFormatTokens","longDateFormat","lastIndex","match1","match2","match3","match4","match6","match1to2","match3to4","match5to6","match1to3","match1to4","match1to6","matchUnsigned","matchSigned","matchOffset","matchShortOffset","matchTimestamp","matchWord","regexes","addRegexToken","regex","strictRegex","isStrict","getParseRegexForToken","unescapeFormat","regexEscape","p1","p2","p3","p4","addParseToken","addWeekParseToken","_w","addTimeToArrayFromToken","_a","YEAR","MONTH","DATE","HOUR","MINUTE","SECOND","MILLISECOND","WEEK","WEEKDAY","daysInMonth","year","month","UTC","getUTCDate","monthsShort","months","monthsShortRegex","monthsRegex","monthsParse","MONTHS_IN_FORMAT","defaultLocaleMonths","localeMonths","_months","defaultLocaleMonthsShort","localeMonthsShort","_monthsShort","localeMonthsParse","monthName","_monthsParse","_longMonthsParse","_shortMonthsParse","setMonth","dayOfMonth","getSetMonth","getDaysInMonth","defaultMonthsShortRegex","_monthsParseExact","computeMonthsParse","_monthsShortStrictRegex","_monthsShortRegex","defaultMonthsRegex","_monthsStrictRegex","_monthsRegex","cmpLenRev","shortPieces","longPieces","mixedPieces","checkOverflow","_overflowDayOfYear","_overflowWeeks","_overflowWeekday","extendedIsoRegex","basicIsoRegex","tzRegex","isoDates","isoTimes","aspNetJsonRegex","configFromISO","allowTime","dateFormat","timeFormat","tzFormat","configFromStringAndFormat","configFromString","createFromInputFallback","_useUTC","createDate","d","h","M","ms","getFullYear","setFullYear","createUTCDate","getUTCFullYear","setUTCFullYear","parseTwoDigitYear","daysInYear","isLeapYear","getSetYear","getIsLeapYear","firstWeekOffset","dow","doy","fwd","fwdlw","getUTCDay","dayOfYearFromWeeks","week","weekday","localWeekday","weekOffset","dayOfYear","resYear","resDayOfYear","weekOfYear","resWeek","weeksInYear","weekOffsetNext","defaults","currentDateArray","nowValue","getUTCMonth","getMonth","getDate","configFromArray","currentDate","yearToUse","dayOfYearFromWeekInfo","_dayOfYear","_nextDay","setUTCMinutes","getUTCMinutes","weekYear","weekdayOverflow","GG","W","E","local__createLocal","_week","gg","ISO_8601","parsedInput","skipped","stringLength","totalParsedInputLength","meridiemFixWrap","_meridiem","hour","meridiem","isPm","meridiemHour","isPM","configFromStringAndArray","tempConfig","bestMoment","scoreToBeat","currentScore","score","configFromObject","day","minute","millisecond","createFromConfig","prepareConfig","preparse","configFromInput","isUTC","prototypeMin","prototypeMax","pickBy","moments","Duration","years","quarters","quarter","weeks","days","hours","minutes","seconds","milliseconds","_milliseconds","_days","_bubble","isDuration","separator","utcOffset","offsetFromString","chunkOffset","chunk","cloneWithOffset","model","setTime","local","getDateOffset","getTimezoneOffset","getSetOffset","keepLocalTime","localAdjust","_changeInProgress","add_subtract__addSubtract","create__createDuration","getSetZone","setOffsetToUTC","setOffsetToLocal","setOffsetToParsedOffset","hasAlignedHourOffset","isDaylightSavingTime","isDaylightSavingTimeShifted","_isDSTShifted","isUtcOffset","isUtc","aspNetRegex","isoRegex","diffRes","parseIso","momentsDifference","inp","positiveMomentsDifference","isAfter","isBefore","absRound","createAdder","direction","period","dur","isAdding","add_subtract__add","add_subtract__subtract","moment_calendar__calendar","formats","sod","startOf","calendar","localInput","endOf","isBetween","isSame","inputMs","isSameOrAfter","isSameOrBefore","asFloat","that","zoneDelta","delta","monthDiff","wholeMonthDiff","anchor","anchor2","adjust","defaultFormat","moment_format__toISOString","toISOString","toDate","inputString","postformat","withoutSuffix","humanize","fromNow","toNow","newLocaleData","isoWeekday","to_type__valueOf","unix","toJSON","moment_valid__isValid","parsingFlags","invalidAt","creationData","isoWeekYear","addWeekYearFormatToken","getSetWeekYear","getSetWeekYearHelper","getSetISOWeekYear","isoWeek","getISOWeeksInYear","getWeeksInYear","weekInfo","weeksTarget","setWeekAll","dayOfYearData","getSetQuarter","localeWeek","defaultLocaleWeek","localeFirstDayOfWeek","localeFirstDayOfYear","getSetWeek","getSetISOWeek","getSetDayOfMonth","weekdaysMin","weekdaysShort","weekdays","weekdaysParse","parseWeekday","defaultLocaleWeekdays","localeWeekdays","_weekdays","isFormat","defaultLocaleWeekdaysShort","localeWeekdaysShort","_weekdaysShort","defaultLocaleWeekdaysMin","localeWeekdaysMin","_weekdaysMin","localeWeekdaysParse","weekdayName","_weekdaysParse","_minWeekdaysParse","_shortWeekdaysParse","_fullWeekdaysParse","getSetDayOfWeek","getDay","getSetLocaleDayOfWeek","getSetISODayOfWeek","getSetDayOfYear","hFormat","lowercase","matchMeridiem","_meridiemParse","_isPm","pos1","pos2","localeIsPM","charAt","defaultLocaleMeridiemParse","localeMeridiem","isLower","getSetHour","getSetMinute","getSetSecond","parseMs","getSetMillisecond","getZoneAbbr","getZoneName","momentPrototype__proto","isoWeeks","isoWeeksInYear","parseZone","isDST","isDSTShifted","zoneAbbr","zoneName","dates","zone","momentPrototype","moment__createUnix","moment__createInZone","defaultCalendar","sameDay","nextDay","nextWeek","lastDay","lastWeek","sameElse","locale_calendar__calendar","_calendar","defaultLongDateFormat","LTS","LT","L","LL","LLL","LLLL","_longDateFormat","formatUpper","defaultInvalidDate","_invalidDate","defaultOrdinal","defaultOrdinalParse","_ordinal","preParsePostFormat","defaultRelativeTime","future","past","mm","hh","dd","MM","yy","relative__relativeTime","isFuture","_relativeTime","pastFuture","prototype__proto","relativeTime","firstDayOfYear","firstDayOfWeek","lists__get","field","out","lists__listMonths","lists__listMonthsShort","lists__listWeekdays","lists__listWeekdaysShort","lists__listWeekdaysMin","ordinalParse","langData","mathAbs","duration_abs__abs","duration_add_subtract__addSubtract","duration_add_subtract__add","duration_add_subtract__subtract","absCeil","bubble","monthsFromDays","monthsToDays","daysToMonths","as","duration_as__valueOf","makeAs","alias","asMilliseconds","asSeconds","asMinutes","asHours","asDays","asWeeks","asMonths","asYears","duration_get__get","makeGetter","thresholds","substituteTimeAgo","duration_humanize__relativeTime","posNegDuration","duration_humanize__getSetRelativeTimeThreshold","threshold","limit","withSuffix","iso_string__abs","iso_string__toISOString","Y","D","total","duration_prototype__proto","toIsoString","invalid","relativeTimeThreshold","_moment","ago","Selectize","Sifter","MicroPlugin","highlight","$element","skip","search","spannode","middlebit","splitText","endbit","middleclone","tagName","MicroEvent","fct","_events","mixin","destObject","IS_MAC","navigator","userAgent","KEY_A","KEY_COMMA","KEY_RETURN","KEY_ESC","KEY_LEFT","KEY_UP","KEY_P","KEY_RIGHT","KEY_DOWN","KEY_N","KEY_BACKSPACE","KEY_DELETE","KEY_SHIFT","KEY_CMD","KEY_CTRL","KEY_TAB","TAG_SELECT","TAG_INPUT","SUPPORTS_VALIDITY_API","validity","isset","hash_key","escape_html","escape_replace","hook","called","debounce","debounce_events","event_args","watchChildEvent","$parent","getSelection","selectionStart","selectionEnd","createRange","selLen","moveStart","transferStyles","$from","$to","measureString","$test","whiteSpace","autoGrow","$input","currentWidth","printable","character","metaKey","altKey","force","substring","shiftKey","selectize","computedStyle","currentStyle","order","tagType","rtl","eventNS","highlightedValue","isOpen","isDisabled","isRequired","isInvalid","isLocked","isFocused","isInputHidden","isSetup","isShiftDown","isCmdDown","isCtrlDown","ignoreFocus","ignoreBlur","ignoreHover","hasOptions","currentResults","lastValue","caretPos","loading","loadedSearches","$activeOption","$activeItems","optgroups","userOptions","items","renderCache","onSearchChange","loadThrottle","sifter","diacritics","registerOption","registerOptionGroup","mode","maxItems","hideSelected","initializePlugins","plugins","setupCallbacks","setupTemplates","$window","$document","$wrapper","$control","$control_input","$dropdown","$dropdown_content","$dropdown_parent","inputMode","timeout_blur","timeout_focus","classes_plugins","wrapperClass","inputClass","dropdownParent","dropdownClass","dropdownContentClass","copyClassesToDropdown","splitOn","delimiter","delimiterEscaped","onOptionHover","onOptionSelect","onItemSelect","mousedown","onMouseDown","onClick","keydown","onKeyDown","onKeyUp","keypress","onKeyPress","resize","positionDropdown","onBlur","onFocus","paste","onPaste","revertSettings","$children","setValue","refreshState","updateOriginalInput","refreshItems","updatePlaceholder","onChange","preload","field_label","labelField","field_optgroup","optgroupLabelField","templates","escape","render","callbacks","$target","setActiveItem","isFull","splitInput","createItem","create","isInput","selectAll","ctrlKey","$next","getAdjacentOption","setActiveOption","$prev","advanceSelection","selectOnTab","deleteSelection","refreshOptions","wasFocused","showInput","openOnFocus","deactivate","setTextboxValue","setCaret","createOnBlur","$option","closeAfterSelect","lastQuery","addItem","getOption","loadingClass","addOption","silent","clear","addItems","$item","eventName","begin","item","$last","hideInput","scroll","height_menu","height_item","scroll_top","scroll_bottom","outerHeight","scrollDuration","getScoreFunction","query","getSearchOptions","sortField","fields","searchField","conjunction","searchConjunction","calculateScore","triggerDropdown","groups_order","option_html","html_children","has_create_option","$active","$active_before","$create","active_before","maxOptions","optgroupField","lockOptgroupOrder","a_order","$order","b_order","canCreate","addPrecedence","valueField","optgroupValueField","addOptionGroup","removeOptionGroup","clearOptionGroups","updateOption","$item_new","value_new","index_item","cache_items","cache_options","order_old","getItem","removeOption","removeItem","clearOptions","getElementWithValue","$options","$els","isPending","value_next","wasFull","insertAtCaret","persist","caret","unlock","refreshClasses","outerWidth","$el","option_select","$option_select","$tail","onDelete","tail","valueLength","cursorAtEdge","advanceCaret","$adj","$child","enable","destroy","templateName","regex_tag","clearCache","createFilter","allowEmptyOption","settings_user","attr_data","field_value","field_optgroup_label","field_optgroup_value","init_textbox","settings_element","data_raw","init_select","optionsMap","readData","group","addGroup","$optgroup","tag_name","sortable","forcePlaceholderSize","ui","helper","title","headerClass","titleRowClass","labelClass","closeClass","$dropdown_header","equalizeWidth","equalizeHeight","getScrollbarWidth","clientWidth","equalizeSizes","height_max","width_last","width_parent","$optgroups","innerWidth","html_container","html_element","render_item","words","escape_regex","DIACRITICS","is_array","forEach","token_count","prepareSearch","scoreValue","scoreObject","field_count","sum","getSortFunction","fields_count","multiplier","multipliers","get_field","implicit_score","sort_empty","cmp","a_value","b_value","option_fields","option_sort","option_sort_empty","fn_sort","fn_score","asciifold","foreignletters","foreignletter","Interface","requested","loaded","utils","loadPlugin","plugin","vArg","Page","RiotPage","unload","unmount","Module","module1","annotations","TableRow","tableData","Table","TableControls","Menu","TableFilterMenu","nameSinglular","namePlural","filterData","countWords","nameSingular","sortWords","column","columns","lsort","resetMenus","$toggle","htmlFor","ignore","filterPlaceholder","noResults","Controls","Forms","Widgets"],"mappings":"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","sourceRoot":"/src"} |