mirror of
https://gitlab.silvrtree.co.uk/martind2000/obrand-admin-server.git
synced 2025-01-11 00:35:08 +00:00
18584 lines
710 KiB
JavaScript
18584 lines
710 KiB
JavaScript
|
|
/** vim: et:ts=4:sw=4:sts=4
|
|
* @license RequireJS 2.1.22 Copyright (c) 2010-2015, The Dojo Foundation All Rights Reserved.
|
|
* Available via the MIT or new BSD license.
|
|
* see: http://github.com/jrburke/requirejs for details
|
|
*/
|
|
//Not using strict: uneven strict support in browsers, #392, and causes
|
|
//problems with requirejs.exec()/transpiler plugins that may not be strict.
|
|
/*jslint regexp: true, nomen: true, sloppy: true */
|
|
/*global window, navigator, document, importScripts, setTimeout, opera */
|
|
|
|
var requirejs, require, define;
|
|
(function (global) {
|
|
var req, s, head, baseElement, dataMain, src,
|
|
interactiveScript, currentlyAddingScript, mainScript, subPath,
|
|
version = '2.1.22',
|
|
commentRegExp = /(\/\*([\s\S]*?)\*\/|([^:]|^)\/\/(.*)$)/mg,
|
|
cjsRequireRegExp = /[^.]\s*require\s*\(\s*["']([^'"\s]+)["']\s*\)/g,
|
|
jsSuffixRegExp = /\.js$/,
|
|
currDirRegExp = /^\.\//,
|
|
op = Object.prototype,
|
|
ostring = op.toString,
|
|
hasOwn = op.hasOwnProperty,
|
|
ap = Array.prototype,
|
|
isBrowser = !!(typeof window !== 'undefined' && typeof navigator !== 'undefined' && window.document),
|
|
isWebWorker = !isBrowser && typeof importScripts !== 'undefined',
|
|
//PS3 indicates loaded and complete, but need to wait for complete
|
|
//specifically. Sequence is 'loading', 'loaded', execution,
|
|
// then 'complete'. The UA check is unfortunate, but not sure how
|
|
//to feature test w/o causing perf issues.
|
|
readyRegExp = isBrowser && navigator.platform === 'PLAYSTATION 3' ?
|
|
/^complete$/ : /^(complete|loaded)$/,
|
|
defContextName = '_',
|
|
//Oh the tragedy, detecting opera. See the usage of isOpera for reason.
|
|
isOpera = typeof opera !== 'undefined' && opera.toString() === '[object Opera]',
|
|
contexts = {},
|
|
cfg = {},
|
|
globalDefQueue = [],
|
|
useInteractive = false;
|
|
|
|
function isFunction(it) {
|
|
return ostring.call(it) === '[object Function]';
|
|
}
|
|
|
|
function isArray(it) {
|
|
return ostring.call(it) === '[object Array]';
|
|
}
|
|
|
|
/**
|
|
* Helper function for iterating over an array. If the func returns
|
|
* a true value, it will break out of the loop.
|
|
*/
|
|
function each(ary, func) {
|
|
if (ary) {
|
|
var i;
|
|
for (i = 0; i < ary.length; i += 1) {
|
|
if (ary[i] && func(ary[i], i, ary)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Helper function for iterating over an array backwards. If the func
|
|
* returns a true value, it will break out of the loop.
|
|
*/
|
|
function eachReverse(ary, func) {
|
|
if (ary) {
|
|
var i;
|
|
for (i = ary.length - 1; i > -1; i -= 1) {
|
|
if (ary[i] && func(ary[i], i, ary)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function hasProp(obj, prop) {
|
|
return hasOwn.call(obj, prop);
|
|
}
|
|
|
|
function getOwn(obj, prop) {
|
|
return hasProp(obj, prop) && obj[prop];
|
|
}
|
|
|
|
/**
|
|
* Cycles over properties in an object and calls a function for each
|
|
* property value. If the function returns a truthy value, then the
|
|
* iteration is stopped.
|
|
*/
|
|
function eachProp(obj, func) {
|
|
var prop;
|
|
for (prop in obj) {
|
|
if (hasProp(obj, prop)) {
|
|
if (func(obj[prop], prop)) {
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Simple function to mix in properties from source into target,
|
|
* but only if target does not already have a property of the same name.
|
|
*/
|
|
function mixin(target, source, force, deepStringMixin) {
|
|
if (source) {
|
|
eachProp(source, function (value, prop) {
|
|
if (force || !hasProp(target, prop)) {
|
|
if (deepStringMixin && typeof value === 'object' && value &&
|
|
!isArray(value) && !isFunction(value) &&
|
|
!(value instanceof RegExp)) {
|
|
|
|
if (!target[prop]) {
|
|
target[prop] = {};
|
|
}
|
|
mixin(target[prop], value, force, deepStringMixin);
|
|
} else {
|
|
target[prop] = value;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
return target;
|
|
}
|
|
|
|
//Similar to Function.prototype.bind, but the 'this' object is specified
|
|
//first, since it is easier to read/figure out what 'this' will be.
|
|
function bind(obj, fn) {
|
|
return function () {
|
|
return fn.apply(obj, arguments);
|
|
};
|
|
}
|
|
|
|
function scripts() {
|
|
return document.getElementsByTagName('script');
|
|
}
|
|
|
|
function defaultOnError(err) {
|
|
throw err;
|
|
}
|
|
|
|
//Allow getting a global that is expressed in
|
|
//dot notation, like 'a.b.c'.
|
|
function getGlobal(value) {
|
|
if (!value) {
|
|
return value;
|
|
}
|
|
var g = global;
|
|
each(value.split('.'), function (part) {
|
|
g = g[part];
|
|
});
|
|
return g;
|
|
}
|
|
|
|
/**
|
|
* Constructs an error with a pointer to an URL with more information.
|
|
* @param {String} id the error ID that maps to an ID on a web page.
|
|
* @param {String} message human readable error.
|
|
* @param {Error} [err] the original error, if there is one.
|
|
*
|
|
* @returns {Error}
|
|
*/
|
|
function makeError(id, msg, err, requireModules) {
|
|
var e = new Error(msg + '\nhttp://requirejs.org/docs/errors.html#' + id);
|
|
e.requireType = id;
|
|
e.requireModules = requireModules;
|
|
if (err) {
|
|
e.originalError = err;
|
|
}
|
|
return e;
|
|
}
|
|
|
|
if (typeof define !== 'undefined') {
|
|
//If a define is already in play via another AMD loader,
|
|
//do not overwrite.
|
|
return;
|
|
}
|
|
|
|
if (typeof requirejs !== 'undefined') {
|
|
if (isFunction(requirejs)) {
|
|
//Do not overwrite an existing requirejs instance.
|
|
return;
|
|
}
|
|
cfg = requirejs;
|
|
requirejs = undefined;
|
|
}
|
|
|
|
//Allow for a require config object
|
|
if (typeof require !== 'undefined' && !isFunction(require)) {
|
|
//assume it is a config object.
|
|
cfg = require;
|
|
require = undefined;
|
|
}
|
|
|
|
function newContext(contextName) {
|
|
var inCheckLoaded, Module, context, handlers,
|
|
checkLoadedTimeoutId,
|
|
config = {
|
|
//Defaults. Do not set a default for map
|
|
//config to speed up normalize(), which
|
|
//will run faster if there is no default.
|
|
waitSeconds: 7,
|
|
baseUrl: './',
|
|
paths: {},
|
|
bundles: {},
|
|
pkgs: {},
|
|
shim: {},
|
|
config: {}
|
|
},
|
|
registry = {},
|
|
//registry of just enabled modules, to speed
|
|
//cycle breaking code when lots of modules
|
|
//are registered, but not activated.
|
|
enabledRegistry = {},
|
|
undefEvents = {},
|
|
defQueue = [],
|
|
defined = {},
|
|
urlFetched = {},
|
|
bundlesMap = {},
|
|
requireCounter = 1,
|
|
unnormalizedCounter = 1;
|
|
|
|
/**
|
|
* Trims the . and .. from an array of path segments.
|
|
* It will keep a leading path segment if a .. will become
|
|
* the first path segment, to help with module name lookups,
|
|
* which act like paths, but can be remapped. But the end result,
|
|
* all paths that use this function should look normalized.
|
|
* NOTE: this method MODIFIES the input array.
|
|
* @param {Array} ary the array of path segments.
|
|
*/
|
|
function trimDots(ary) {
|
|
var i, part;
|
|
for (i = 0; i < ary.length; i++) {
|
|
part = ary[i];
|
|
if (part === '.') {
|
|
ary.splice(i, 1);
|
|
i -= 1;
|
|
} else if (part === '..') {
|
|
// If at the start, or previous value is still ..,
|
|
// keep them so that when converted to a path it may
|
|
// still work when converted to a path, even though
|
|
// as an ID it is less than ideal. In larger point
|
|
// releases, may be better to just kick out an error.
|
|
if (i === 0 || (i === 1 && ary[2] === '..') || ary[i - 1] === '..') {
|
|
continue;
|
|
} else if (i > 0) {
|
|
ary.splice(i - 1, 2);
|
|
i -= 2;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given a relative module name, like ./something, normalize it to
|
|
* a real name that can be mapped to a path.
|
|
* @param {String} name the relative name
|
|
* @param {String} baseName a real name that the name arg is relative
|
|
* to.
|
|
* @param {Boolean} applyMap apply the map config to the value. Should
|
|
* only be done if this normalization is for a dependency ID.
|
|
* @returns {String} normalized name
|
|
*/
|
|
function normalize(name, baseName, applyMap) {
|
|
var pkgMain, mapValue, nameParts, i, j, nameSegment, lastIndex,
|
|
foundMap, foundI, foundStarMap, starI, normalizedBaseParts,
|
|
baseParts = (baseName && baseName.split('/')),
|
|
map = config.map,
|
|
starMap = map && map['*'];
|
|
|
|
//Adjust any relative paths.
|
|
if (name) {
|
|
name = name.split('/');
|
|
lastIndex = name.length - 1;
|
|
|
|
// If wanting node ID compatibility, strip .js from end
|
|
// of IDs. Have to do this here, and not in nameToUrl
|
|
// because node allows either .js or non .js to map
|
|
// to same file.
|
|
if (config.nodeIdCompat && jsSuffixRegExp.test(name[lastIndex])) {
|
|
name[lastIndex] = name[lastIndex].replace(jsSuffixRegExp, '');
|
|
}
|
|
|
|
// Starts with a '.' so need the baseName
|
|
if (name[0].charAt(0) === '.' && baseParts) {
|
|
//Convert baseName to array, and lop off the last part,
|
|
//so that . matches that 'directory' and not name of the baseName's
|
|
//module. For instance, baseName of 'one/two/three', maps to
|
|
//'one/two/three.js', but we want the directory, 'one/two' for
|
|
//this normalization.
|
|
normalizedBaseParts = baseParts.slice(0, baseParts.length - 1);
|
|
name = normalizedBaseParts.concat(name);
|
|
}
|
|
|
|
trimDots(name);
|
|
name = name.join('/');
|
|
}
|
|
|
|
//Apply map config if available.
|
|
if (applyMap && map && (baseParts || starMap)) {
|
|
nameParts = name.split('/');
|
|
|
|
outerLoop: for (i = nameParts.length; i > 0; i -= 1) {
|
|
nameSegment = nameParts.slice(0, i).join('/');
|
|
|
|
if (baseParts) {
|
|
//Find the longest baseName segment match in the config.
|
|
//So, do joins on the biggest to smallest lengths of baseParts.
|
|
for (j = baseParts.length; j > 0; j -= 1) {
|
|
mapValue = getOwn(map, baseParts.slice(0, j).join('/'));
|
|
|
|
//baseName segment has config, find if it has one for
|
|
//this name.
|
|
if (mapValue) {
|
|
mapValue = getOwn(mapValue, nameSegment);
|
|
if (mapValue) {
|
|
//Match, update name to the new value.
|
|
foundMap = mapValue;
|
|
foundI = i;
|
|
break outerLoop;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//Check for a star map match, but just hold on to it,
|
|
//if there is a shorter segment match later in a matching
|
|
//config, then favor over this star map.
|
|
if (!foundStarMap && starMap && getOwn(starMap, nameSegment)) {
|
|
foundStarMap = getOwn(starMap, nameSegment);
|
|
starI = i;
|
|
}
|
|
}
|
|
|
|
if (!foundMap && foundStarMap) {
|
|
foundMap = foundStarMap;
|
|
foundI = starI;
|
|
}
|
|
|
|
if (foundMap) {
|
|
nameParts.splice(0, foundI, foundMap);
|
|
name = nameParts.join('/');
|
|
}
|
|
}
|
|
|
|
// If the name points to a package's name, use
|
|
// the package main instead.
|
|
pkgMain = getOwn(config.pkgs, name);
|
|
|
|
return pkgMain ? pkgMain : name;
|
|
}
|
|
|
|
function removeScript(name) {
|
|
if (isBrowser) {
|
|
each(scripts(), function (scriptNode) {
|
|
if (scriptNode.getAttribute('data-requiremodule') === name &&
|
|
scriptNode.getAttribute('data-requirecontext') === context.contextName) {
|
|
scriptNode.parentNode.removeChild(scriptNode);
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
}
|
|
|
|
function hasPathFallback(id) {
|
|
var pathConfig = getOwn(config.paths, id);
|
|
if (pathConfig && isArray(pathConfig) && pathConfig.length > 1) {
|
|
//Pop off the first array value, since it failed, and
|
|
//retry
|
|
pathConfig.shift();
|
|
context.require.undef(id);
|
|
|
|
//Custom require that does not do map translation, since
|
|
//ID is "absolute", already mapped/resolved.
|
|
context.makeRequire(null, {
|
|
skipMap: true
|
|
})([id]);
|
|
|
|
return true;
|
|
}
|
|
}
|
|
|
|
//Turns a plugin!resource to [plugin, resource]
|
|
//with the plugin being undefined if the name
|
|
//did not have a plugin prefix.
|
|
function splitPrefix(name) {
|
|
var prefix,
|
|
index = name ? name.indexOf('!') : -1;
|
|
if (index > -1) {
|
|
prefix = name.substring(0, index);
|
|
name = name.substring(index + 1, name.length);
|
|
}
|
|
return [prefix, name];
|
|
}
|
|
|
|
/**
|
|
* Creates a module mapping that includes plugin prefix, module
|
|
* name, and path. If parentModuleMap is provided it will
|
|
* also normalize the name via require.normalize()
|
|
*
|
|
* @param {String} name the module name
|
|
* @param {String} [parentModuleMap] parent module map
|
|
* for the module name, used to resolve relative names.
|
|
* @param {Boolean} isNormalized: is the ID already normalized.
|
|
* This is true if this call is done for a define() module ID.
|
|
* @param {Boolean} applyMap: apply the map config to the ID.
|
|
* Should only be true if this map is for a dependency.
|
|
*
|
|
* @returns {Object}
|
|
*/
|
|
function makeModuleMap(name, parentModuleMap, isNormalized, applyMap) {
|
|
var url, pluginModule, suffix, nameParts,
|
|
prefix = null,
|
|
parentName = parentModuleMap ? parentModuleMap.name : null,
|
|
originalName = name,
|
|
isDefine = true,
|
|
normalizedName = '';
|
|
|
|
//If no name, then it means it is a require call, generate an
|
|
//internal name.
|
|
if (!name) {
|
|
isDefine = false;
|
|
name = '_@r' + (requireCounter += 1);
|
|
}
|
|
|
|
nameParts = splitPrefix(name);
|
|
prefix = nameParts[0];
|
|
name = nameParts[1];
|
|
|
|
if (prefix) {
|
|
prefix = normalize(prefix, parentName, applyMap);
|
|
pluginModule = getOwn(defined, prefix);
|
|
}
|
|
|
|
//Account for relative paths if there is a base name.
|
|
if (name) {
|
|
if (prefix) {
|
|
if (pluginModule && pluginModule.normalize) {
|
|
//Plugin is loaded, use its normalize method.
|
|
normalizedName = pluginModule.normalize(name, function (name) {
|
|
return normalize(name, parentName, applyMap);
|
|
});
|
|
} else {
|
|
// If nested plugin references, then do not try to
|
|
// normalize, as it will not normalize correctly. This
|
|
// places a restriction on resourceIds, and the longer
|
|
// term solution is not to normalize until plugins are
|
|
// loaded and all normalizations to allow for async
|
|
// loading of a loader plugin. But for now, fixes the
|
|
// common uses. Details in #1131
|
|
normalizedName = name.indexOf('!') === -1 ?
|
|
normalize(name, parentName, applyMap) :
|
|
name;
|
|
}
|
|
} else {
|
|
//A regular module.
|
|
normalizedName = normalize(name, parentName, applyMap);
|
|
|
|
//Normalized name may be a plugin ID due to map config
|
|
//application in normalize. The map config values must
|
|
//already be normalized, so do not need to redo that part.
|
|
nameParts = splitPrefix(normalizedName);
|
|
prefix = nameParts[0];
|
|
normalizedName = nameParts[1];
|
|
isNormalized = true;
|
|
|
|
url = context.nameToUrl(normalizedName);
|
|
}
|
|
}
|
|
|
|
//If the id is a plugin id that cannot be determined if it needs
|
|
//normalization, stamp it with a unique ID so two matching relative
|
|
//ids that may conflict can be separate.
|
|
suffix = prefix && !pluginModule && !isNormalized ?
|
|
'_unnormalized' + (unnormalizedCounter += 1) :
|
|
'';
|
|
|
|
return {
|
|
prefix: prefix,
|
|
name: normalizedName,
|
|
parentMap: parentModuleMap,
|
|
unnormalized: !!suffix,
|
|
url: url,
|
|
originalName: originalName,
|
|
isDefine: isDefine,
|
|
id: (prefix ?
|
|
prefix + '!' + normalizedName :
|
|
normalizedName) + suffix
|
|
};
|
|
}
|
|
|
|
function getModule(depMap) {
|
|
var id = depMap.id,
|
|
mod = getOwn(registry, id);
|
|
|
|
if (!mod) {
|
|
mod = registry[id] = new context.Module(depMap);
|
|
}
|
|
|
|
return mod;
|
|
}
|
|
|
|
function on(depMap, name, fn) {
|
|
var id = depMap.id,
|
|
mod = getOwn(registry, id);
|
|
|
|
if (hasProp(defined, id) &&
|
|
(!mod || mod.defineEmitComplete)) {
|
|
if (name === 'defined') {
|
|
fn(defined[id]);
|
|
}
|
|
} else {
|
|
mod = getModule(depMap);
|
|
if (mod.error && name === 'error') {
|
|
fn(mod.error);
|
|
} else {
|
|
mod.on(name, fn);
|
|
}
|
|
}
|
|
}
|
|
|
|
function onError(err, errback) {
|
|
var ids = err.requireModules,
|
|
notified = false;
|
|
|
|
if (errback) {
|
|
errback(err);
|
|
} else {
|
|
each(ids, function (id) {
|
|
var mod = getOwn(registry, id);
|
|
if (mod) {
|
|
//Set error on module, so it skips timeout checks.
|
|
mod.error = err;
|
|
if (mod.events.error) {
|
|
notified = true;
|
|
mod.emit('error', err);
|
|
}
|
|
}
|
|
});
|
|
|
|
if (!notified) {
|
|
req.onError(err);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Internal method to transfer globalQueue items to this context's
|
|
* defQueue.
|
|
*/
|
|
function takeGlobalQueue() {
|
|
//Push all the globalDefQueue items into the context's defQueue
|
|
if (globalDefQueue.length) {
|
|
each(globalDefQueue, function(queueItem) {
|
|
var id = queueItem[0];
|
|
if (typeof id === 'string') {
|
|
context.defQueueMap[id] = true;
|
|
}
|
|
defQueue.push(queueItem);
|
|
});
|
|
globalDefQueue = [];
|
|
}
|
|
}
|
|
|
|
handlers = {
|
|
'require': function (mod) {
|
|
if (mod.require) {
|
|
return mod.require;
|
|
} else {
|
|
return (mod.require = context.makeRequire(mod.map));
|
|
}
|
|
},
|
|
'exports': function (mod) {
|
|
mod.usingExports = true;
|
|
if (mod.map.isDefine) {
|
|
if (mod.exports) {
|
|
return (defined[mod.map.id] = mod.exports);
|
|
} else {
|
|
return (mod.exports = defined[mod.map.id] = {});
|
|
}
|
|
}
|
|
},
|
|
'module': function (mod) {
|
|
if (mod.module) {
|
|
return mod.module;
|
|
} else {
|
|
return (mod.module = {
|
|
id: mod.map.id,
|
|
uri: mod.map.url,
|
|
config: function () {
|
|
return getOwn(config.config, mod.map.id) || {};
|
|
},
|
|
exports: mod.exports || (mod.exports = {})
|
|
});
|
|
}
|
|
}
|
|
};
|
|
|
|
function cleanRegistry(id) {
|
|
//Clean up machinery used for waiting modules.
|
|
delete registry[id];
|
|
delete enabledRegistry[id];
|
|
}
|
|
|
|
function breakCycle(mod, traced, processed) {
|
|
var id = mod.map.id;
|
|
|
|
if (mod.error) {
|
|
mod.emit('error', mod.error);
|
|
} else {
|
|
traced[id] = true;
|
|
each(mod.depMaps, function (depMap, i) {
|
|
var depId = depMap.id,
|
|
dep = getOwn(registry, depId);
|
|
|
|
//Only force things that have not completed
|
|
//being defined, so still in the registry,
|
|
//and only if it has not been matched up
|
|
//in the module already.
|
|
if (dep && !mod.depMatched[i] && !processed[depId]) {
|
|
if (getOwn(traced, depId)) {
|
|
mod.defineDep(i, defined[depId]);
|
|
mod.check(); //pass false?
|
|
} else {
|
|
breakCycle(dep, traced, processed);
|
|
}
|
|
}
|
|
});
|
|
processed[id] = true;
|
|
}
|
|
}
|
|
|
|
function checkLoaded() {
|
|
var err, usingPathFallback,
|
|
waitInterval = config.waitSeconds * 1000,
|
|
//It is possible to disable the wait interval by using waitSeconds of 0.
|
|
expired = waitInterval && (context.startTime + waitInterval) < new Date().getTime(),
|
|
noLoads = [],
|
|
reqCalls = [],
|
|
stillLoading = false,
|
|
needCycleCheck = true;
|
|
|
|
//Do not bother if this call was a result of a cycle break.
|
|
if (inCheckLoaded) {
|
|
return;
|
|
}
|
|
|
|
inCheckLoaded = true;
|
|
|
|
//Figure out the state of all the modules.
|
|
eachProp(enabledRegistry, function (mod) {
|
|
var map = mod.map,
|
|
modId = map.id;
|
|
|
|
//Skip things that are not enabled or in error state.
|
|
if (!mod.enabled) {
|
|
return;
|
|
}
|
|
|
|
if (!map.isDefine) {
|
|
reqCalls.push(mod);
|
|
}
|
|
|
|
if (!mod.error) {
|
|
//If the module should be executed, and it has not
|
|
//been inited and time is up, remember it.
|
|
if (!mod.inited && expired) {
|
|
if (hasPathFallback(modId)) {
|
|
usingPathFallback = true;
|
|
stillLoading = true;
|
|
} else {
|
|
noLoads.push(modId);
|
|
removeScript(modId);
|
|
}
|
|
} else if (!mod.inited && mod.fetched && map.isDefine) {
|
|
stillLoading = true;
|
|
if (!map.prefix) {
|
|
//No reason to keep looking for unfinished
|
|
//loading. If the only stillLoading is a
|
|
//plugin resource though, keep going,
|
|
//because it may be that a plugin resource
|
|
//is waiting on a non-plugin cycle.
|
|
return (needCycleCheck = false);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
if (expired && noLoads.length) {
|
|
//If wait time expired, throw error of unloaded modules.
|
|
err = makeError('timeout', 'Load timeout for modules: ' + noLoads, null, noLoads);
|
|
err.contextName = context.contextName;
|
|
return onError(err);
|
|
}
|
|
|
|
//Not expired, check for a cycle.
|
|
if (needCycleCheck) {
|
|
each(reqCalls, function (mod) {
|
|
breakCycle(mod, {}, {});
|
|
});
|
|
}
|
|
|
|
//If still waiting on loads, and the waiting load is something
|
|
//other than a plugin resource, or there are still outstanding
|
|
//scripts, then just try back later.
|
|
if ((!expired || usingPathFallback) && stillLoading) {
|
|
//Something is still waiting to load. Wait for it, but only
|
|
//if a timeout is not already in effect.
|
|
if ((isBrowser || isWebWorker) && !checkLoadedTimeoutId) {
|
|
checkLoadedTimeoutId = setTimeout(function () {
|
|
checkLoadedTimeoutId = 0;
|
|
checkLoaded();
|
|
}, 50);
|
|
}
|
|
}
|
|
|
|
inCheckLoaded = false;
|
|
}
|
|
|
|
Module = function (map) {
|
|
this.events = getOwn(undefEvents, map.id) || {};
|
|
this.map = map;
|
|
this.shim = getOwn(config.shim, map.id);
|
|
this.depExports = [];
|
|
this.depMaps = [];
|
|
this.depMatched = [];
|
|
this.pluginMaps = {};
|
|
this.depCount = 0;
|
|
|
|
/* this.exports this.factory
|
|
this.depMaps = [],
|
|
this.enabled, this.fetched
|
|
*/
|
|
};
|
|
|
|
Module.prototype = {
|
|
init: function (depMaps, factory, errback, options) {
|
|
options = options || {};
|
|
|
|
//Do not do more inits if already done. Can happen if there
|
|
//are multiple define calls for the same module. That is not
|
|
//a normal, common case, but it is also not unexpected.
|
|
if (this.inited) {
|
|
return;
|
|
}
|
|
|
|
this.factory = factory;
|
|
|
|
if (errback) {
|
|
//Register for errors on this module.
|
|
this.on('error', errback);
|
|
} else if (this.events.error) {
|
|
//If no errback already, but there are error listeners
|
|
//on this module, set up an errback to pass to the deps.
|
|
errback = bind(this, function (err) {
|
|
this.emit('error', err);
|
|
});
|
|
}
|
|
|
|
//Do a copy of the dependency array, so that
|
|
//source inputs are not modified. For example
|
|
//"shim" deps are passed in here directly, and
|
|
//doing a direct modification of the depMaps array
|
|
//would affect that config.
|
|
this.depMaps = depMaps && depMaps.slice(0);
|
|
|
|
this.errback = errback;
|
|
|
|
//Indicate this module has be initialized
|
|
this.inited = true;
|
|
|
|
this.ignore = options.ignore;
|
|
|
|
//Could have option to init this module in enabled mode,
|
|
//or could have been previously marked as enabled. However,
|
|
//the dependencies are not known until init is called. So
|
|
//if enabled previously, now trigger dependencies as enabled.
|
|
if (options.enabled || this.enabled) {
|
|
//Enable this module and dependencies.
|
|
//Will call this.check()
|
|
this.enable();
|
|
} else {
|
|
this.check();
|
|
}
|
|
},
|
|
|
|
defineDep: function (i, depExports) {
|
|
//Because of cycles, defined callback for a given
|
|
//export can be called more than once.
|
|
if (!this.depMatched[i]) {
|
|
this.depMatched[i] = true;
|
|
this.depCount -= 1;
|
|
this.depExports[i] = depExports;
|
|
}
|
|
},
|
|
|
|
fetch: function () {
|
|
if (this.fetched) {
|
|
return;
|
|
}
|
|
this.fetched = true;
|
|
|
|
context.startTime = (new Date()).getTime();
|
|
|
|
var map = this.map;
|
|
|
|
//If the manager is for a plugin managed resource,
|
|
//ask the plugin to load it now.
|
|
if (this.shim) {
|
|
context.makeRequire(this.map, {
|
|
enableBuildCallback: true
|
|
})(this.shim.deps || [], bind(this, function () {
|
|
return map.prefix ? this.callPlugin() : this.load();
|
|
}));
|
|
} else {
|
|
//Regular dependency.
|
|
return map.prefix ? this.callPlugin() : this.load();
|
|
}
|
|
},
|
|
|
|
load: function () {
|
|
var url = this.map.url;
|
|
|
|
//Regular dependency.
|
|
if (!urlFetched[url]) {
|
|
urlFetched[url] = true;
|
|
context.load(this.map.id, url);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Checks if the module is ready to define itself, and if so,
|
|
* define it.
|
|
*/
|
|
check: function () {
|
|
if (!this.enabled || this.enabling) {
|
|
return;
|
|
}
|
|
|
|
var err, cjsModule,
|
|
id = this.map.id,
|
|
depExports = this.depExports,
|
|
exports = this.exports,
|
|
factory = this.factory;
|
|
|
|
if (!this.inited) {
|
|
// Only fetch if not already in the defQueue.
|
|
if (!hasProp(context.defQueueMap, id)) {
|
|
this.fetch();
|
|
}
|
|
} else if (this.error) {
|
|
this.emit('error', this.error);
|
|
} else if (!this.defining) {
|
|
//The factory could trigger another require call
|
|
//that would result in checking this module to
|
|
//define itself again. If already in the process
|
|
//of doing that, skip this work.
|
|
this.defining = true;
|
|
|
|
if (this.depCount < 1 && !this.defined) {
|
|
if (isFunction(factory)) {
|
|
try {
|
|
exports = context.execCb(id, factory, depExports, exports);
|
|
} catch (e) {
|
|
err = e;
|
|
}
|
|
|
|
// Favor return value over exports. If node/cjs in play,
|
|
// then will not have a return value anyway. Favor
|
|
// module.exports assignment over exports object.
|
|
if (this.map.isDefine && exports === undefined) {
|
|
cjsModule = this.module;
|
|
if (cjsModule) {
|
|
exports = cjsModule.exports;
|
|
} else if (this.usingExports) {
|
|
//exports already set the defined value.
|
|
exports = this.exports;
|
|
}
|
|
}
|
|
|
|
if (err) {
|
|
// If there is an error listener, favor passing
|
|
// to that instead of throwing an error. However,
|
|
// only do it for define()'d modules. require
|
|
// errbacks should not be called for failures in
|
|
// their callbacks (#699). However if a global
|
|
// onError is set, use that.
|
|
if ((this.events.error && this.map.isDefine) ||
|
|
req.onError !== defaultOnError) {
|
|
err.requireMap = this.map;
|
|
err.requireModules = this.map.isDefine ? [this.map.id] : null;
|
|
err.requireType = this.map.isDefine ? 'define' : 'require';
|
|
return onError((this.error = err));
|
|
} else if (typeof console !== 'undefined' &&
|
|
console.error) {
|
|
// Log the error for debugging. If promises could be
|
|
// used, this would be different, but making do.
|
|
console.error(err);
|
|
} else {
|
|
// Do not want to completely lose the error. While this
|
|
// will mess up processing and lead to similar results
|
|
// as bug 1440, it at least surfaces the error.
|
|
req.onError(err);
|
|
}
|
|
}
|
|
} else {
|
|
//Just a literal value
|
|
exports = factory;
|
|
}
|
|
|
|
this.exports = exports;
|
|
|
|
if (this.map.isDefine && !this.ignore) {
|
|
defined[id] = exports;
|
|
|
|
if (req.onResourceLoad) {
|
|
var resLoadMaps = [];
|
|
each(this.depMaps, function (depMap) {
|
|
resLoadMaps.push(depMap.normalizedMap || depMap);
|
|
});
|
|
req.onResourceLoad(context, this.map, resLoadMaps);
|
|
}
|
|
}
|
|
|
|
//Clean up
|
|
cleanRegistry(id);
|
|
|
|
this.defined = true;
|
|
}
|
|
|
|
//Finished the define stage. Allow calling check again
|
|
//to allow define notifications below in the case of a
|
|
//cycle.
|
|
this.defining = false;
|
|
|
|
if (this.defined && !this.defineEmitted) {
|
|
this.defineEmitted = true;
|
|
this.emit('defined', this.exports);
|
|
this.defineEmitComplete = true;
|
|
}
|
|
|
|
}
|
|
},
|
|
|
|
callPlugin: function () {
|
|
var map = this.map,
|
|
id = map.id,
|
|
//Map already normalized the prefix.
|
|
pluginMap = makeModuleMap(map.prefix);
|
|
|
|
//Mark this as a dependency for this plugin, so it
|
|
//can be traced for cycles.
|
|
this.depMaps.push(pluginMap);
|
|
|
|
on(pluginMap, 'defined', bind(this, function (plugin) {
|
|
var load, normalizedMap, normalizedMod,
|
|
bundleId = getOwn(bundlesMap, this.map.id),
|
|
name = this.map.name,
|
|
parentName = this.map.parentMap ? this.map.parentMap.name : null,
|
|
localRequire = context.makeRequire(map.parentMap, {
|
|
enableBuildCallback: true
|
|
});
|
|
|
|
//If current map is not normalized, wait for that
|
|
//normalized name to load instead of continuing.
|
|
if (this.map.unnormalized) {
|
|
//Normalize the ID if the plugin allows it.
|
|
if (plugin.normalize) {
|
|
name = plugin.normalize(name, function (name) {
|
|
return normalize(name, parentName, true);
|
|
}) || '';
|
|
}
|
|
|
|
//prefix and name should already be normalized, no need
|
|
//for applying map config again either.
|
|
normalizedMap = makeModuleMap(map.prefix + '!' + name,
|
|
this.map.parentMap);
|
|
on(normalizedMap,
|
|
'defined', bind(this, function (value) {
|
|
this.map.normalizedMap = normalizedMap;
|
|
this.init([], function () { return value; }, null, {
|
|
enabled: true,
|
|
ignore: true
|
|
});
|
|
}));
|
|
|
|
normalizedMod = getOwn(registry, normalizedMap.id);
|
|
if (normalizedMod) {
|
|
//Mark this as a dependency for this plugin, so it
|
|
//can be traced for cycles.
|
|
this.depMaps.push(normalizedMap);
|
|
|
|
if (this.events.error) {
|
|
normalizedMod.on('error', bind(this, function (err) {
|
|
this.emit('error', err);
|
|
}));
|
|
}
|
|
normalizedMod.enable();
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//If a paths config, then just load that file instead to
|
|
//resolve the plugin, as it is built into that paths layer.
|
|
if (bundleId) {
|
|
this.map.url = context.nameToUrl(bundleId);
|
|
this.load();
|
|
return;
|
|
}
|
|
|
|
load = bind(this, function (value) {
|
|
this.init([], function () { return value; }, null, {
|
|
enabled: true
|
|
});
|
|
});
|
|
|
|
load.error = bind(this, function (err) {
|
|
this.inited = true;
|
|
this.error = err;
|
|
err.requireModules = [id];
|
|
|
|
//Remove temp unnormalized modules for this module,
|
|
//since they will never be resolved otherwise now.
|
|
eachProp(registry, function (mod) {
|
|
if (mod.map.id.indexOf(id + '_unnormalized') === 0) {
|
|
cleanRegistry(mod.map.id);
|
|
}
|
|
});
|
|
|
|
onError(err);
|
|
});
|
|
|
|
//Allow plugins to load other code without having to know the
|
|
//context or how to 'complete' the load.
|
|
load.fromText = bind(this, function (text, textAlt) {
|
|
/*jslint evil: true */
|
|
var moduleName = map.name,
|
|
moduleMap = makeModuleMap(moduleName),
|
|
hasInteractive = useInteractive;
|
|
|
|
//As of 2.1.0, support just passing the text, to reinforce
|
|
//fromText only being called once per resource. Still
|
|
//support old style of passing moduleName but discard
|
|
//that moduleName in favor of the internal ref.
|
|
if (textAlt) {
|
|
text = textAlt;
|
|
}
|
|
|
|
//Turn off interactive script matching for IE for any define
|
|
//calls in the text, then turn it back on at the end.
|
|
if (hasInteractive) {
|
|
useInteractive = false;
|
|
}
|
|
|
|
//Prime the system by creating a module instance for
|
|
//it.
|
|
getModule(moduleMap);
|
|
|
|
//Transfer any config to this other module.
|
|
if (hasProp(config.config, id)) {
|
|
config.config[moduleName] = config.config[id];
|
|
}
|
|
|
|
try {
|
|
req.exec(text);
|
|
} catch (e) {
|
|
return onError(makeError('fromtexteval',
|
|
'fromText eval for ' + id +
|
|
' failed: ' + e,
|
|
e,
|
|
[id]));
|
|
}
|
|
|
|
if (hasInteractive) {
|
|
useInteractive = true;
|
|
}
|
|
|
|
//Mark this as a dependency for the plugin
|
|
//resource
|
|
this.depMaps.push(moduleMap);
|
|
|
|
//Support anonymous modules.
|
|
context.completeLoad(moduleName);
|
|
|
|
//Bind the value of that module to the value for this
|
|
//resource ID.
|
|
localRequire([moduleName], load);
|
|
});
|
|
|
|
//Use parentName here since the plugin's name is not reliable,
|
|
//could be some weird string with no path that actually wants to
|
|
//reference the parentName's path.
|
|
plugin.load(map.name, localRequire, load, config);
|
|
}));
|
|
|
|
context.enable(pluginMap, this);
|
|
this.pluginMaps[pluginMap.id] = pluginMap;
|
|
},
|
|
|
|
enable: function () {
|
|
enabledRegistry[this.map.id] = this;
|
|
this.enabled = true;
|
|
|
|
//Set flag mentioning that the module is enabling,
|
|
//so that immediate calls to the defined callbacks
|
|
//for dependencies do not trigger inadvertent load
|
|
//with the depCount still being zero.
|
|
this.enabling = true;
|
|
|
|
//Enable each dependency
|
|
each(this.depMaps, bind(this, function (depMap, i) {
|
|
var id, mod, handler;
|
|
|
|
if (typeof depMap === 'string') {
|
|
//Dependency needs to be converted to a depMap
|
|
//and wired up to this module.
|
|
depMap = makeModuleMap(depMap,
|
|
(this.map.isDefine ? this.map : this.map.parentMap),
|
|
false,
|
|
!this.skipMap);
|
|
this.depMaps[i] = depMap;
|
|
|
|
handler = getOwn(handlers, depMap.id);
|
|
|
|
if (handler) {
|
|
this.depExports[i] = handler(this);
|
|
return;
|
|
}
|
|
|
|
this.depCount += 1;
|
|
|
|
on(depMap, 'defined', bind(this, function (depExports) {
|
|
if (this.undefed) {
|
|
return;
|
|
}
|
|
this.defineDep(i, depExports);
|
|
this.check();
|
|
}));
|
|
|
|
if (this.errback) {
|
|
on(depMap, 'error', bind(this, this.errback));
|
|
} else if (this.events.error) {
|
|
// No direct errback on this module, but something
|
|
// else is listening for errors, so be sure to
|
|
// propagate the error correctly.
|
|
on(depMap, 'error', bind(this, function(err) {
|
|
this.emit('error', err);
|
|
}));
|
|
}
|
|
}
|
|
|
|
id = depMap.id;
|
|
mod = registry[id];
|
|
|
|
//Skip special modules like 'require', 'exports', 'module'
|
|
//Also, don't call enable if it is already enabled,
|
|
//important in circular dependency cases.
|
|
if (!hasProp(handlers, id) && mod && !mod.enabled) {
|
|
context.enable(depMap, this);
|
|
}
|
|
}));
|
|
|
|
//Enable each plugin that is used in
|
|
//a dependency
|
|
eachProp(this.pluginMaps, bind(this, function (pluginMap) {
|
|
var mod = getOwn(registry, pluginMap.id);
|
|
if (mod && !mod.enabled) {
|
|
context.enable(pluginMap, this);
|
|
}
|
|
}));
|
|
|
|
this.enabling = false;
|
|
|
|
this.check();
|
|
},
|
|
|
|
on: function (name, cb) {
|
|
var cbs = this.events[name];
|
|
if (!cbs) {
|
|
cbs = this.events[name] = [];
|
|
}
|
|
cbs.push(cb);
|
|
},
|
|
|
|
emit: function (name, evt) {
|
|
each(this.events[name], function (cb) {
|
|
cb(evt);
|
|
});
|
|
if (name === 'error') {
|
|
//Now that the error handler was triggered, remove
|
|
//the listeners, since this broken Module instance
|
|
//can stay around for a while in the registry.
|
|
delete this.events[name];
|
|
}
|
|
}
|
|
};
|
|
|
|
function callGetModule(args) {
|
|
//Skip modules already defined.
|
|
if (!hasProp(defined, args[0])) {
|
|
getModule(makeModuleMap(args[0], null, true)).init(args[1], args[2]);
|
|
}
|
|
}
|
|
|
|
function removeListener(node, func, name, ieName) {
|
|
//Favor detachEvent because of IE9
|
|
//issue, see attachEvent/addEventListener comment elsewhere
|
|
//in this file.
|
|
if (node.detachEvent && !isOpera) {
|
|
//Probably IE. If not it will throw an error, which will be
|
|
//useful to know.
|
|
if (ieName) {
|
|
node.detachEvent(ieName, func);
|
|
}
|
|
} else {
|
|
node.removeEventListener(name, func, false);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Given an event from a script node, get the requirejs info from it,
|
|
* and then removes the event listeners on the node.
|
|
* @param {Event} evt
|
|
* @returns {Object}
|
|
*/
|
|
function getScriptData(evt) {
|
|
//Using currentTarget instead of target for Firefox 2.0's sake. Not
|
|
//all old browsers will be supported, but this one was easy enough
|
|
//to support and still makes sense.
|
|
var node = evt.currentTarget || evt.srcElement;
|
|
|
|
//Remove the listeners once here.
|
|
removeListener(node, context.onScriptLoad, 'load', 'onreadystatechange');
|
|
removeListener(node, context.onScriptError, 'error');
|
|
|
|
return {
|
|
node: node,
|
|
id: node && node.getAttribute('data-requiremodule')
|
|
};
|
|
}
|
|
|
|
function intakeDefines() {
|
|
var args;
|
|
|
|
//Any defined modules in the global queue, intake them now.
|
|
takeGlobalQueue();
|
|
|
|
//Make sure any remaining defQueue items get properly processed.
|
|
while (defQueue.length) {
|
|
args = defQueue.shift();
|
|
if (args[0] === null) {
|
|
return onError(makeError('mismatch', 'Mismatched anonymous define() module: ' +
|
|
args[args.length - 1]));
|
|
} else {
|
|
//args are id, deps, factory. Should be normalized by the
|
|
//define() function.
|
|
callGetModule(args);
|
|
}
|
|
}
|
|
context.defQueueMap = {};
|
|
}
|
|
|
|
context = {
|
|
config: config,
|
|
contextName: contextName,
|
|
registry: registry,
|
|
defined: defined,
|
|
urlFetched: urlFetched,
|
|
defQueue: defQueue,
|
|
defQueueMap: {},
|
|
Module: Module,
|
|
makeModuleMap: makeModuleMap,
|
|
nextTick: req.nextTick,
|
|
onError: onError,
|
|
|
|
/**
|
|
* Set a configuration for the context.
|
|
* @param {Object} cfg config object to integrate.
|
|
*/
|
|
configure: function (cfg) {
|
|
//Make sure the baseUrl ends in a slash.
|
|
if (cfg.baseUrl) {
|
|
if (cfg.baseUrl.charAt(cfg.baseUrl.length - 1) !== '/') {
|
|
cfg.baseUrl += '/';
|
|
}
|
|
}
|
|
|
|
//Save off the paths since they require special processing,
|
|
//they are additive.
|
|
var shim = config.shim,
|
|
objs = {
|
|
paths: true,
|
|
bundles: true,
|
|
config: true,
|
|
map: true
|
|
};
|
|
|
|
eachProp(cfg, function (value, prop) {
|
|
if (objs[prop]) {
|
|
if (!config[prop]) {
|
|
config[prop] = {};
|
|
}
|
|
mixin(config[prop], value, true, true);
|
|
} else {
|
|
config[prop] = value;
|
|
}
|
|
});
|
|
|
|
//Reverse map the bundles
|
|
if (cfg.bundles) {
|
|
eachProp(cfg.bundles, function (value, prop) {
|
|
each(value, function (v) {
|
|
if (v !== prop) {
|
|
bundlesMap[v] = prop;
|
|
}
|
|
});
|
|
});
|
|
}
|
|
|
|
//Merge shim
|
|
if (cfg.shim) {
|
|
eachProp(cfg.shim, function (value, id) {
|
|
//Normalize the structure
|
|
if (isArray(value)) {
|
|
value = {
|
|
deps: value
|
|
};
|
|
}
|
|
if ((value.exports || value.init) && !value.exportsFn) {
|
|
value.exportsFn = context.makeShimExports(value);
|
|
}
|
|
shim[id] = value;
|
|
});
|
|
config.shim = shim;
|
|
}
|
|
|
|
//Adjust packages if necessary.
|
|
if (cfg.packages) {
|
|
each(cfg.packages, function (pkgObj) {
|
|
var location, name;
|
|
|
|
pkgObj = typeof pkgObj === 'string' ? {name: pkgObj} : pkgObj;
|
|
|
|
name = pkgObj.name;
|
|
location = pkgObj.location;
|
|
if (location) {
|
|
config.paths[name] = pkgObj.location;
|
|
}
|
|
|
|
//Save pointer to main module ID for pkg name.
|
|
//Remove leading dot in main, so main paths are normalized,
|
|
//and remove any trailing .js, since different package
|
|
//envs have different conventions: some use a module name,
|
|
//some use a file name.
|
|
config.pkgs[name] = pkgObj.name + '/' + (pkgObj.main || 'main')
|
|
.replace(currDirRegExp, '')
|
|
.replace(jsSuffixRegExp, '');
|
|
});
|
|
}
|
|
|
|
//If there are any "waiting to execute" modules in the registry,
|
|
//update the maps for them, since their info, like URLs to load,
|
|
//may have changed.
|
|
eachProp(registry, function (mod, id) {
|
|
//If module already has init called, since it is too
|
|
//late to modify them, and ignore unnormalized ones
|
|
//since they are transient.
|
|
if (!mod.inited && !mod.map.unnormalized) {
|
|
mod.map = makeModuleMap(id, null, true);
|
|
}
|
|
});
|
|
|
|
//If a deps array or a config callback is specified, then call
|
|
//require with those args. This is useful when require is defined as a
|
|
//config object before require.js is loaded.
|
|
if (cfg.deps || cfg.callback) {
|
|
context.require(cfg.deps || [], cfg.callback);
|
|
}
|
|
},
|
|
|
|
makeShimExports: function (value) {
|
|
function fn() {
|
|
var ret;
|
|
if (value.init) {
|
|
ret = value.init.apply(global, arguments);
|
|
}
|
|
return ret || (value.exports && getGlobal(value.exports));
|
|
}
|
|
return fn;
|
|
},
|
|
|
|
makeRequire: function (relMap, options) {
|
|
options = options || {};
|
|
|
|
function localRequire(deps, callback, errback) {
|
|
var id, map, requireMod;
|
|
|
|
if (options.enableBuildCallback && callback && isFunction(callback)) {
|
|
callback.__requireJsBuild = true;
|
|
}
|
|
|
|
if (typeof deps === 'string') {
|
|
if (isFunction(callback)) {
|
|
//Invalid call
|
|
return onError(makeError('requireargs', 'Invalid require call'), errback);
|
|
}
|
|
|
|
//If require|exports|module are requested, get the
|
|
//value for them from the special handlers. Caveat:
|
|
//this only works while module is being defined.
|
|
if (relMap && hasProp(handlers, deps)) {
|
|
return handlers[deps](registry[relMap.id]);
|
|
}
|
|
|
|
//Synchronous access to one module. If require.get is
|
|
//available (as in the Node adapter), prefer that.
|
|
if (req.get) {
|
|
return req.get(context, deps, relMap, localRequire);
|
|
}
|
|
|
|
//Normalize module name, if it contains . or ..
|
|
map = makeModuleMap(deps, relMap, false, true);
|
|
id = map.id;
|
|
|
|
if (!hasProp(defined, id)) {
|
|
return onError(makeError('notloaded', 'Module name "' +
|
|
id +
|
|
'" has not been loaded yet for context: ' +
|
|
contextName +
|
|
(relMap ? '' : '. Use require([])')));
|
|
}
|
|
return defined[id];
|
|
}
|
|
|
|
//Grab defines waiting in the global queue.
|
|
intakeDefines();
|
|
|
|
//Mark all the dependencies as needing to be loaded.
|
|
context.nextTick(function () {
|
|
//Some defines could have been added since the
|
|
//require call, collect them.
|
|
intakeDefines();
|
|
|
|
requireMod = getModule(makeModuleMap(null, relMap));
|
|
|
|
//Store if map config should be applied to this require
|
|
//call for dependencies.
|
|
requireMod.skipMap = options.skipMap;
|
|
|
|
requireMod.init(deps, callback, errback, {
|
|
enabled: true
|
|
});
|
|
|
|
checkLoaded();
|
|
});
|
|
|
|
return localRequire;
|
|
}
|
|
|
|
mixin(localRequire, {
|
|
isBrowser: isBrowser,
|
|
|
|
/**
|
|
* Converts a module name + .extension into an URL path.
|
|
* *Requires* the use of a module name. It does not support using
|
|
* plain URLs like nameToUrl.
|
|
*/
|
|
toUrl: function (moduleNamePlusExt) {
|
|
var ext,
|
|
index = moduleNamePlusExt.lastIndexOf('.'),
|
|
segment = moduleNamePlusExt.split('/')[0],
|
|
isRelative = segment === '.' || segment === '..';
|
|
|
|
//Have a file extension alias, and it is not the
|
|
//dots from a relative path.
|
|
if (index !== -1 && (!isRelative || index > 1)) {
|
|
ext = moduleNamePlusExt.substring(index, moduleNamePlusExt.length);
|
|
moduleNamePlusExt = moduleNamePlusExt.substring(0, index);
|
|
}
|
|
|
|
return context.nameToUrl(normalize(moduleNamePlusExt,
|
|
relMap && relMap.id, true), ext, true);
|
|
},
|
|
|
|
defined: function (id) {
|
|
return hasProp(defined, makeModuleMap(id, relMap, false, true).id);
|
|
},
|
|
|
|
specified: function (id) {
|
|
id = makeModuleMap(id, relMap, false, true).id;
|
|
return hasProp(defined, id) || hasProp(registry, id);
|
|
}
|
|
});
|
|
|
|
//Only allow undef on top level require calls
|
|
if (!relMap) {
|
|
localRequire.undef = function (id) {
|
|
//Bind any waiting define() calls to this context,
|
|
//fix for #408
|
|
takeGlobalQueue();
|
|
|
|
var map = makeModuleMap(id, relMap, true),
|
|
mod = getOwn(registry, id);
|
|
|
|
mod.undefed = true;
|
|
removeScript(id);
|
|
|
|
delete defined[id];
|
|
delete urlFetched[map.url];
|
|
delete undefEvents[id];
|
|
|
|
//Clean queued defines too. Go backwards
|
|
//in array so that the splices do not
|
|
//mess up the iteration.
|
|
eachReverse(defQueue, function(args, i) {
|
|
if (args[0] === id) {
|
|
defQueue.splice(i, 1);
|
|
}
|
|
});
|
|
delete context.defQueueMap[id];
|
|
|
|
if (mod) {
|
|
//Hold on to listeners in case the
|
|
//module will be attempted to be reloaded
|
|
//using a different config.
|
|
if (mod.events.defined) {
|
|
undefEvents[id] = mod.events;
|
|
}
|
|
|
|
cleanRegistry(id);
|
|
}
|
|
};
|
|
}
|
|
|
|
return localRequire;
|
|
},
|
|
|
|
/**
|
|
* Called to enable a module if it is still in the registry
|
|
* awaiting enablement. A second arg, parent, the parent module,
|
|
* is passed in for context, when this method is overridden by
|
|
* the optimizer. Not shown here to keep code compact.
|
|
*/
|
|
enable: function (depMap) {
|
|
var mod = getOwn(registry, depMap.id);
|
|
if (mod) {
|
|
getModule(depMap).enable();
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Internal method used by environment adapters to complete a load event.
|
|
* A load event could be a script load or just a load pass from a synchronous
|
|
* load call.
|
|
* @param {String} moduleName the name of the module to potentially complete.
|
|
*/
|
|
completeLoad: function (moduleName) {
|
|
var found, args, mod,
|
|
shim = getOwn(config.shim, moduleName) || {},
|
|
shExports = shim.exports;
|
|
|
|
takeGlobalQueue();
|
|
|
|
while (defQueue.length) {
|
|
args = defQueue.shift();
|
|
if (args[0] === null) {
|
|
args[0] = moduleName;
|
|
//If already found an anonymous module and bound it
|
|
//to this name, then this is some other anon module
|
|
//waiting for its completeLoad to fire.
|
|
if (found) {
|
|
break;
|
|
}
|
|
found = true;
|
|
} else if (args[0] === moduleName) {
|
|
//Found matching define call for this script!
|
|
found = true;
|
|
}
|
|
|
|
callGetModule(args);
|
|
}
|
|
context.defQueueMap = {};
|
|
|
|
//Do this after the cycle of callGetModule in case the result
|
|
//of those calls/init calls changes the registry.
|
|
mod = getOwn(registry, moduleName);
|
|
|
|
if (!found && !hasProp(defined, moduleName) && mod && !mod.inited) {
|
|
if (config.enforceDefine && (!shExports || !getGlobal(shExports))) {
|
|
if (hasPathFallback(moduleName)) {
|
|
return;
|
|
} else {
|
|
return onError(makeError('nodefine',
|
|
'No define call for ' + moduleName,
|
|
null,
|
|
[moduleName]));
|
|
}
|
|
} else {
|
|
//A script that does not call define(), so just simulate
|
|
//the call for it.
|
|
callGetModule([moduleName, (shim.deps || []), shim.exportsFn]);
|
|
}
|
|
}
|
|
|
|
checkLoaded();
|
|
},
|
|
|
|
/**
|
|
* Converts a module name to a file path. Supports cases where
|
|
* moduleName may actually be just an URL.
|
|
* Note that it **does not** call normalize on the moduleName,
|
|
* it is assumed to have already been normalized. This is an
|
|
* internal API, not a public one. Use toUrl for the public API.
|
|
*/
|
|
nameToUrl: function (moduleName, ext, skipExt) {
|
|
var paths, syms, i, parentModule, url,
|
|
parentPath, bundleId,
|
|
pkgMain = getOwn(config.pkgs, moduleName);
|
|
|
|
if (pkgMain) {
|
|
moduleName = pkgMain;
|
|
}
|
|
|
|
bundleId = getOwn(bundlesMap, moduleName);
|
|
|
|
if (bundleId) {
|
|
return context.nameToUrl(bundleId, ext, skipExt);
|
|
}
|
|
|
|
//If a colon is in the URL, it indicates a protocol is used and it is just
|
|
//an URL to a file, or if it starts with a slash, contains a query arg (i.e. ?)
|
|
//or ends with .js, then assume the user meant to use an url and not a module id.
|
|
//The slash is important for protocol-less URLs as well as full paths.
|
|
if (req.jsExtRegExp.test(moduleName)) {
|
|
//Just a plain path, not module name lookup, so just return it.
|
|
//Add extension if it is included. This is a bit wonky, only non-.js things pass
|
|
//an extension, this method probably needs to be reworked.
|
|
url = moduleName + (ext || '');
|
|
} else {
|
|
//A module that needs to be converted to a path.
|
|
paths = config.paths;
|
|
|
|
syms = moduleName.split('/');
|
|
//For each module name segment, see if there is a path
|
|
//registered for it. Start with most specific name
|
|
//and work up from it.
|
|
for (i = syms.length; i > 0; i -= 1) {
|
|
parentModule = syms.slice(0, i).join('/');
|
|
|
|
parentPath = getOwn(paths, parentModule);
|
|
if (parentPath) {
|
|
//If an array, it means there are a few choices,
|
|
//Choose the one that is desired
|
|
if (isArray(parentPath)) {
|
|
parentPath = parentPath[0];
|
|
}
|
|
syms.splice(0, i, parentPath);
|
|
break;
|
|
}
|
|
}
|
|
|
|
//Join the path parts together, then figure out if baseUrl is needed.
|
|
url = syms.join('/');
|
|
url += (ext || (/^data\:|\?/.test(url) || skipExt ? '' : '.js'));
|
|
url = (url.charAt(0) === '/' || url.match(/^[\w\+\.\-]+:/) ? '' : config.baseUrl) + url;
|
|
}
|
|
|
|
return config.urlArgs ? url +
|
|
((url.indexOf('?') === -1 ? '?' : '&') +
|
|
config.urlArgs) : url;
|
|
},
|
|
|
|
//Delegates to req.load. Broken out as a separate function to
|
|
//allow overriding in the optimizer.
|
|
load: function (id, url) {
|
|
req.load(context, id, url);
|
|
},
|
|
|
|
/**
|
|
* Executes a module callback function. Broken out as a separate function
|
|
* solely to allow the build system to sequence the files in the built
|
|
* layer in the right sequence.
|
|
*
|
|
* @private
|
|
*/
|
|
execCb: function (name, callback, args, exports) {
|
|
return callback.apply(exports, args);
|
|
},
|
|
|
|
/**
|
|
* callback for script loads, used to check status of loading.
|
|
*
|
|
* @param {Event} evt the event from the browser for the script
|
|
* that was loaded.
|
|
*/
|
|
onScriptLoad: function (evt) {
|
|
//Using currentTarget instead of target for Firefox 2.0's sake. Not
|
|
//all old browsers will be supported, but this one was easy enough
|
|
//to support and still makes sense.
|
|
if (evt.type === 'load' ||
|
|
(readyRegExp.test((evt.currentTarget || evt.srcElement).readyState))) {
|
|
//Reset interactive script so a script node is not held onto for
|
|
//to long.
|
|
interactiveScript = null;
|
|
|
|
//Pull out the name of the module and the context.
|
|
var data = getScriptData(evt);
|
|
context.completeLoad(data.id);
|
|
}
|
|
},
|
|
|
|
/**
|
|
* Callback for script errors.
|
|
*/
|
|
onScriptError: function (evt) {
|
|
var data = getScriptData(evt);
|
|
if (!hasPathFallback(data.id)) {
|
|
var parents = [];
|
|
eachProp(registry, function(value, key) {
|
|
if (key.indexOf('_@r') !== 0) {
|
|
each(value.depMaps, function(depMap) {
|
|
if (depMap.id === data.id) {
|
|
parents.push(key);
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
});
|
|
return onError(makeError('scripterror', 'Script error for "' + data.id +
|
|
(parents.length ?
|
|
'", needed by: ' + parents.join(', ') :
|
|
'"'), evt, [data.id]));
|
|
}
|
|
}
|
|
};
|
|
|
|
context.require = context.makeRequire();
|
|
return context;
|
|
}
|
|
|
|
/**
|
|
* Main entry point.
|
|
*
|
|
* If the only argument to require is a string, then the module that
|
|
* is represented by that string is fetched for the appropriate context.
|
|
*
|
|
* If the first argument is an array, then it will be treated as an array
|
|
* of dependency string names to fetch. An optional function callback can
|
|
* be specified to execute when all of those dependencies are available.
|
|
*
|
|
* Make a local req variable to help Caja compliance (it assumes things
|
|
* on a require that are not standardized), and to give a short
|
|
* name for minification/local scope use.
|
|
*/
|
|
req = requirejs = function (deps, callback, errback, optional) {
|
|
|
|
//Find the right context, use default
|
|
var context, config,
|
|
contextName = defContextName;
|
|
|
|
// Determine if have config object in the call.
|
|
if (!isArray(deps) && typeof deps !== 'string') {
|
|
// deps is a config object
|
|
config = deps;
|
|
if (isArray(callback)) {
|
|
// Adjust args if there are dependencies
|
|
deps = callback;
|
|
callback = errback;
|
|
errback = optional;
|
|
} else {
|
|
deps = [];
|
|
}
|
|
}
|
|
|
|
if (config && config.context) {
|
|
contextName = config.context;
|
|
}
|
|
|
|
context = getOwn(contexts, contextName);
|
|
if (!context) {
|
|
context = contexts[contextName] = req.s.newContext(contextName);
|
|
}
|
|
|
|
if (config) {
|
|
context.configure(config);
|
|
}
|
|
|
|
return context.require(deps, callback, errback);
|
|
};
|
|
|
|
/**
|
|
* Support require.config() to make it easier to cooperate with other
|
|
* AMD loaders on globally agreed names.
|
|
*/
|
|
req.config = function (config) {
|
|
return req(config);
|
|
};
|
|
|
|
/**
|
|
* Execute something after the current tick
|
|
* of the event loop. Override for other envs
|
|
* that have a better solution than setTimeout.
|
|
* @param {Function} fn function to execute later.
|
|
*/
|
|
req.nextTick = typeof setTimeout !== 'undefined' ? function (fn) {
|
|
setTimeout(fn, 4);
|
|
} : function (fn) { fn(); };
|
|
|
|
/**
|
|
* Export require as a global, but only if it does not already exist.
|
|
*/
|
|
if (!require) {
|
|
require = req;
|
|
}
|
|
|
|
req.version = version;
|
|
|
|
//Used to filter out dependencies that are already paths.
|
|
req.jsExtRegExp = /^\/|:|\?|\.js$/;
|
|
req.isBrowser = isBrowser;
|
|
s = req.s = {
|
|
contexts: contexts,
|
|
newContext: newContext
|
|
};
|
|
|
|
//Create default context.
|
|
req({});
|
|
|
|
//Exports some context-sensitive methods on global require.
|
|
each([
|
|
'toUrl',
|
|
'undef',
|
|
'defined',
|
|
'specified'
|
|
], function (prop) {
|
|
//Reference from contexts instead of early binding to default context,
|
|
//so that during builds, the latest instance of the default context
|
|
//with its config gets used.
|
|
req[prop] = function () {
|
|
var ctx = contexts[defContextName];
|
|
return ctx.require[prop].apply(ctx, arguments);
|
|
};
|
|
});
|
|
|
|
if (isBrowser) {
|
|
head = s.head = document.getElementsByTagName('head')[0];
|
|
//If BASE tag is in play, using appendChild is a problem for IE6.
|
|
//When that browser dies, this can be removed. Details in this jQuery bug:
|
|
//http://dev.jquery.com/ticket/2709
|
|
baseElement = document.getElementsByTagName('base')[0];
|
|
if (baseElement) {
|
|
head = s.head = baseElement.parentNode;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Any errors that require explicitly generates will be passed to this
|
|
* function. Intercept/override it if you want custom error handling.
|
|
* @param {Error} err the error object.
|
|
*/
|
|
req.onError = defaultOnError;
|
|
|
|
/**
|
|
* Creates the node for the load command. Only used in browser envs.
|
|
*/
|
|
req.createNode = function (config, moduleName, url) {
|
|
var node = config.xhtml ?
|
|
document.createElementNS('http://www.w3.org/1999/xhtml', 'html:script') :
|
|
document.createElement('script');
|
|
node.type = config.scriptType || 'text/javascript';
|
|
node.charset = 'utf-8';
|
|
node.async = true;
|
|
return node;
|
|
};
|
|
|
|
/**
|
|
* Does the request to load a module for the browser case.
|
|
* Make this a separate function to allow other environments
|
|
* to override it.
|
|
*
|
|
* @param {Object} context the require context to find state.
|
|
* @param {String} moduleName the name of the module.
|
|
* @param {Object} url the URL to the module.
|
|
*/
|
|
req.load = function (context, moduleName, url) {
|
|
var config = (context && context.config) || {},
|
|
node;
|
|
if (isBrowser) {
|
|
//In the browser so use a script tag
|
|
node = req.createNode(config, moduleName, url);
|
|
if (config.onNodeCreated) {
|
|
config.onNodeCreated(node, config, moduleName, url);
|
|
}
|
|
|
|
node.setAttribute('data-requirecontext', context.contextName);
|
|
node.setAttribute('data-requiremodule', moduleName);
|
|
|
|
//Set up load listener. Test attachEvent first because IE9 has
|
|
//a subtle issue in its addEventListener and script onload firings
|
|
//that do not match the behavior of all other browsers with
|
|
//addEventListener support, which fire the onload event for a
|
|
//script right after the script execution. See:
|
|
//https://connect.microsoft.com/IE/feedback/details/648057/script-onload-event-is-not-fired-immediately-after-script-execution
|
|
//UNFORTUNATELY Opera implements attachEvent but does not follow the script
|
|
//script execution mode.
|
|
if (node.attachEvent &&
|
|
//Check if node.attachEvent is artificially added by custom script or
|
|
//natively supported by browser
|
|
//read https://github.com/jrburke/requirejs/issues/187
|
|
//if we can NOT find [native code] then it must NOT natively supported.
|
|
//in IE8, node.attachEvent does not have toString()
|
|
//Note the test for "[native code" with no closing brace, see:
|
|
//https://github.com/jrburke/requirejs/issues/273
|
|
!(node.attachEvent.toString && node.attachEvent.toString().indexOf('[native code') < 0) &&
|
|
!isOpera) {
|
|
//Probably IE. IE (at least 6-8) do not fire
|
|
//script onload right after executing the script, so
|
|
//we cannot tie the anonymous define call to a name.
|
|
//However, IE reports the script as being in 'interactive'
|
|
//readyState at the time of the define call.
|
|
useInteractive = true;
|
|
|
|
node.attachEvent('onreadystatechange', context.onScriptLoad);
|
|
//It would be great to add an error handler here to catch
|
|
//404s in IE9+. However, onreadystatechange will fire before
|
|
//the error handler, so that does not help. If addEventListener
|
|
//is used, then IE will fire error before load, but we cannot
|
|
//use that pathway given the connect.microsoft.com issue
|
|
//mentioned above about not doing the 'script execute,
|
|
//then fire the script load event listener before execute
|
|
//next script' that other browsers do.
|
|
//Best hope: IE10 fixes the issues,
|
|
//and then destroys all installs of IE 6-9.
|
|
//node.attachEvent('onerror', context.onScriptError);
|
|
} else {
|
|
node.addEventListener('load', context.onScriptLoad, false);
|
|
node.addEventListener('error', context.onScriptError, false);
|
|
}
|
|
node.src = url;
|
|
|
|
//For some cache cases in IE 6-8, the script executes before the end
|
|
//of the appendChild execution, so to tie an anonymous define
|
|
//call to the module name (which is stored on the node), hold on
|
|
//to a reference to this node, but clear after the DOM insertion.
|
|
currentlyAddingScript = node;
|
|
if (baseElement) {
|
|
head.insertBefore(node, baseElement);
|
|
} else {
|
|
head.appendChild(node);
|
|
}
|
|
currentlyAddingScript = null;
|
|
|
|
return node;
|
|
} else if (isWebWorker) {
|
|
try {
|
|
//In a web worker, use importScripts. This is not a very
|
|
//efficient use of importScripts, importScripts will block until
|
|
//its script is downloaded and evaluated. However, if web workers
|
|
//are in play, the expectation is that a build has been done so
|
|
//that only one script needs to be loaded anyway. This may need
|
|
//to be reevaluated if other use cases become common.
|
|
importScripts(url);
|
|
|
|
//Account for anonymous modules
|
|
context.completeLoad(moduleName);
|
|
} catch (e) {
|
|
context.onError(makeError('importscripts',
|
|
'importScripts failed for ' +
|
|
moduleName + ' at ' + url,
|
|
e,
|
|
[moduleName]));
|
|
}
|
|
}
|
|
};
|
|
|
|
function getInteractiveScript() {
|
|
if (interactiveScript && interactiveScript.readyState === 'interactive') {
|
|
return interactiveScript;
|
|
}
|
|
|
|
eachReverse(scripts(), function (script) {
|
|
if (script.readyState === 'interactive') {
|
|
return (interactiveScript = script);
|
|
}
|
|
});
|
|
return interactiveScript;
|
|
}
|
|
|
|
//Look for a data-main script attribute, which could also adjust the baseUrl.
|
|
if (isBrowser && !cfg.skipDataMain) {
|
|
//Figure out baseUrl. Get it from the script tag with require.js in it.
|
|
eachReverse(scripts(), function (script) {
|
|
//Set the 'head' where we can append children by
|
|
//using the script's parent.
|
|
if (!head) {
|
|
head = script.parentNode;
|
|
}
|
|
|
|
//Look for a data-main attribute to set main script for the page
|
|
//to load. If it is there, the path to data main becomes the
|
|
//baseUrl, if it is not already set.
|
|
dataMain = script.getAttribute('data-main');
|
|
if (dataMain) {
|
|
//Preserve dataMain in case it is a path (i.e. contains '?')
|
|
mainScript = dataMain;
|
|
|
|
//Set final baseUrl if there is not already an explicit one.
|
|
if (!cfg.baseUrl) {
|
|
//Pull off the directory of data-main for use as the
|
|
//baseUrl.
|
|
src = mainScript.split('/');
|
|
mainScript = src.pop();
|
|
subPath = src.length ? src.join('/') + '/' : './';
|
|
|
|
cfg.baseUrl = subPath;
|
|
}
|
|
|
|
//Strip off any trailing .js since mainScript is now
|
|
//like a module name.
|
|
mainScript = mainScript.replace(jsSuffixRegExp, '');
|
|
|
|
//If mainScript is still a path, fall back to dataMain
|
|
if (req.jsExtRegExp.test(mainScript)) {
|
|
mainScript = dataMain;
|
|
}
|
|
|
|
//Put the data-main script in the files to load.
|
|
cfg.deps = cfg.deps ? cfg.deps.concat(mainScript) : [mainScript];
|
|
|
|
return true;
|
|
}
|
|
});
|
|
}
|
|
|
|
/**
|
|
* The function that handles definitions of modules. Differs from
|
|
* require() in that a string for the module should be the first argument,
|
|
* and the function to execute after dependencies are loaded should
|
|
* return a value to define the module corresponding to the first argument's
|
|
* name.
|
|
*/
|
|
define = function (name, deps, callback) {
|
|
var node, context;
|
|
|
|
//Allow for anonymous modules
|
|
if (typeof name !== 'string') {
|
|
//Adjust args appropriately
|
|
callback = deps;
|
|
deps = name;
|
|
name = null;
|
|
}
|
|
|
|
//This module may not have dependencies
|
|
if (!isArray(deps)) {
|
|
callback = deps;
|
|
deps = null;
|
|
}
|
|
|
|
//If no name, and callback is a function, then figure out if it a
|
|
//CommonJS thing with dependencies.
|
|
if (!deps && isFunction(callback)) {
|
|
deps = [];
|
|
//Remove comments from the callback string,
|
|
//look for require calls, and pull them into the dependencies,
|
|
//but only if there are function args.
|
|
if (callback.length) {
|
|
callback
|
|
.toString()
|
|
.replace(commentRegExp, '')
|
|
.replace(cjsRequireRegExp, function (match, dep) {
|
|
deps.push(dep);
|
|
});
|
|
|
|
//May be a CommonJS thing even without require calls, but still
|
|
//could use exports, and module. Avoid doing exports and module
|
|
//work though if it just needs require.
|
|
//REQUIRES the function to expect the CommonJS variables in the
|
|
//order listed below.
|
|
deps = (callback.length === 1 ? ['require'] : ['require', 'exports', 'module']).concat(deps);
|
|
}
|
|
}
|
|
|
|
//If in IE 6-8 and hit an anonymous define() call, do the interactive
|
|
//work.
|
|
if (useInteractive) {
|
|
node = currentlyAddingScript || getInteractiveScript();
|
|
if (node) {
|
|
if (!name) {
|
|
name = node.getAttribute('data-requiremodule');
|
|
}
|
|
context = contexts[node.getAttribute('data-requirecontext')];
|
|
}
|
|
}
|
|
|
|
//Always save off evaluating the def call until the script onload handler.
|
|
//This allows multiple modules to be in a file without prematurely
|
|
//tracing dependencies, and allows for anonymous module support,
|
|
//where the module name is not known until the script onload event
|
|
//occurs. If no context, use the global queue, and get it processed
|
|
//in the onscript load callback.
|
|
if (context) {
|
|
context.defQueue.push([name, deps, callback]);
|
|
context.defQueueMap[name] = true;
|
|
} else {
|
|
globalDefQueue.push([name, deps, callback]);
|
|
}
|
|
};
|
|
|
|
define.amd = {
|
|
jQuery: true
|
|
};
|
|
|
|
/**
|
|
* Executes the text. Normally just uses eval, but can be modified
|
|
* to use a better, environment-specific call. Only used for transpiling
|
|
* loader plugins, not for plain JS modules.
|
|
* @param {String} text the text to execute/evaluate.
|
|
*/
|
|
req.exec = function (text) {
|
|
/*jslint evil: true */
|
|
return eval(text);
|
|
};
|
|
|
|
//Set up with config info.
|
|
req(cfg);
|
|
}(this));
|
|
|
|
define("requireLib", function(){});
|
|
|
|
/*!
|
|
* jQuery JavaScript Library v2.2.3
|
|
* 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-04-05T19:26Z
|
|
*/
|
|
|
|
(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)
|
|
//
|
|
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.3",
|
|
|
|
// 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 ?
|
|
|
|
// Return just the one element from the set
|
|
( 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 - 0x10000;
|
|
// 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 + 0x10000 ) :
|
|
// Supplemental Plane codepoint (surrogate pair)
|
|
String.fromCharCode( high >> 10 | 0xD800, high & 0x3FF | 0xDC00 );
|
|
},
|
|
|
|
// 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 ) &&
|
|
// Get excess from tokenize (recursively)
|
|
(excess = tokenize( unquoted, true )) &&
|
|
// advance to the next closing parenthesis
|
|
(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 ] ||
|
|
|
|
// Fallback to seeking `elem` from the start
|
|
(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" &&
|
|
|
|
// Support: IE<8
|
|
// New HTML5 attribute values (e.g., "search") appear with 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 /* Internal Use Only */ ) {
|
|
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( /* fnDone, fnFail, fnProgress */ ) {
|
|
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 /* , ..., subordinateN */ ) {
|
|
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 ) &&
|
|
|
|
// Don't return options that are disabled or in a disabled optgroup
|
|
( 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]*)$/mg,
|
|
|
|
// #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( this, 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;
|
|
}));
|
|
|
|
/*!
|
|
* Bootstrap v3.1.1 (http://getbootstrap.com)
|
|
* Copyright 2011-2014 Twitter, Inc.
|
|
* Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
|
|
*/
|
|
if("undefined"==typeof jQuery)throw new Error("Bootstrap's JavaScript requires jQuery");+function(a){function b(){var a=document.createElement("bootstrap"),b={WebkitTransition:"webkitTransitionEnd",MozTransition:"transitionend",OTransition:"oTransitionEnd otransitionend",transition:"transitionend"};for(var c in b)if(void 0!==a.style[c])return{end:b[c]};return!1}a.fn.emulateTransitionEnd=function(b){var c=!1,d=this;a(this).one(a.support.transition.end,function(){c=!0});var e=function(){c||a(d).trigger(a.support.transition.end)};return setTimeout(e,b),this},a(function(){a.support.transition=b()})}(jQuery),+function(a){var b='[data-dismiss="alert"]',c=function(c){a(c).on("click",b,this.close)};c.prototype.close=function(b){function c(){f.trigger("closed.bs.alert").remove()}var d=a(this),e=d.attr("data-target");e||(e=d.attr("href"),e=e&&e.replace(/.*(?=#[^\s]*$)/,""));var f=a(e);b&&b.preventDefault(),f.length||(f=d.hasClass("alert")?d:d.parent()),f.trigger(b=a.Event("close.bs.alert")),b.isDefaultPrevented()||(f.removeClass("in"),a.support.transition&&f.hasClass("fade")?f.one(a.support.transition.end,c).emulateTransitionEnd(150):c())};var d=a.fn.alert;a.fn.alert=function(b){return this.each(function(){var d=a(this),e=d.data("bs.alert");e||d.data("bs.alert",e=new c(this)),"string"==typeof b&&e[b].call(d)})},a.fn.alert.Constructor=c,a.fn.alert.noConflict=function(){return a.fn.alert=d,this},a(document).on("click.bs.alert.data-api",b,c.prototype.close)}(jQuery),+function(a){var b=function(c,d){this.$element=a(c),this.options=a.extend({},b.DEFAULTS,d),this.isLoading=!1};b.DEFAULTS={loadingText:"loading..."},b.prototype.setState=function(b){var c="disabled",d=this.$element,e=d.is("input")?"val":"html",f=d.data();b+="Text",f.resetText||d.data("resetText",d[e]()),d[e](f[b]||this.options[b]),setTimeout(a.proxy(function(){"loadingText"==b?(this.isLoading=!0,d.addClass(c).attr(c,c)):this.isLoading&&(this.isLoading=!1,d.removeClass(c).removeAttr(c))},this),0)},b.prototype.toggle=function(){var a=!0,b=this.$element.closest('[data-toggle="buttons"]');if(b.length){var c=this.$element.find("input");"radio"==c.prop("type")&&(c.prop("checked")&&this.$element.hasClass("active")?a=!1:b.find(".active").removeClass("active")),a&&c.prop("checked",!this.$element.hasClass("active")).trigger("change")}a&&this.$element.toggleClass("active")};var c=a.fn.button;a.fn.button=function(c){return this.each(function(){var d=a(this),e=d.data("bs.button"),f="object"==typeof c&&c;e||d.data("bs.button",e=new b(this,f)),"toggle"==c?e.toggle():c&&e.setState(c)})},a.fn.button.Constructor=b,a.fn.button.noConflict=function(){return a.fn.button=c,this},a(document).on("click.bs.button.data-api","[data-toggle^=button]",function(b){var c=a(b.target);c.hasClass("btn")||(c=c.closest(".btn")),c.button("toggle"),b.preventDefault()})}(jQuery),+function(a){var b=function(b,c){this.$element=a(b),this.$indicators=this.$element.find(".carousel-indicators"),this.options=c,this.paused=this.sliding=this.interval=this.$active=this.$items=null,"hover"==this.options.pause&&this.$element.on("mouseenter",a.proxy(this.pause,this)).on("mouseleave",a.proxy(this.cycle,this))};b.DEFAULTS={interval:5e3,pause:"hover",wrap:!0},b.prototype.cycle=function(b){return b||(this.paused=!1),this.interval&&clearInterval(this.interval),this.options.interval&&!this.paused&&(this.interval=setInterval(a.proxy(this.next,this),this.options.interval)),this},b.prototype.getActiveIndex=function(){return this.$active=this.$element.find(".item.active"),this.$items=this.$active.parent().children(),this.$items.index(this.$active)},b.prototype.to=function(b){var c=this,d=this.getActiveIndex();return b>this.$items.length-1||0>b?void 0:this.sliding?this.$element.one("slid.bs.carousel",function(){c.to(b)}):d==b?this.pause().cycle():this.slide(b>d?"next":"prev",a(this.$items[b]))},b.prototype.pause=function(b){return b||(this.paused=!0),this.$element.find(".next, .prev").length&&a.support.transition&&(this.$element.trigger(a.support.transition.end),this.cycle(!0)),this.interval=clearInterval(this.interval),this},b.prototype.next=function(){return this.sliding?void 0:this.slide("next")},b.prototype.prev=function(){return this.sliding?void 0:this.slide("prev")},b.prototype.slide=function(b,c){var d=this.$element.find(".item.active"),e=c||d[b](),f=this.interval,g="next"==b?"left":"right",h="next"==b?"first":"last",i=this;if(!e.length){if(!this.options.wrap)return;e=this.$element.find(".item")[h]()}if(e.hasClass("active"))return this.sliding=!1;var j=a.Event("slide.bs.carousel",{relatedTarget:e[0],direction:g});return this.$element.trigger(j),j.isDefaultPrevented()?void 0:(this.sliding=!0,f&&this.pause(),this.$indicators.length&&(this.$indicators.find(".active").removeClass("active"),this.$element.one("slid.bs.carousel",function(){var b=a(i.$indicators.children()[i.getActiveIndex()]);b&&b.addClass("active")})),a.support.transition&&this.$element.hasClass("slide")?(e.addClass(b),e[0].offsetWidth,d.addClass(g),e.addClass(g),d.one(a.support.transition.end,function(){e.removeClass([b,g].join(" ")).addClass("active"),d.removeClass(["active",g].join(" ")),i.sliding=!1,setTimeout(function(){i.$element.trigger("slid.bs.carousel")},0)}).emulateTransitionEnd(1e3*d.css("transition-duration").slice(0,-1))):(d.removeClass("active"),e.addClass("active"),this.sliding=!1,this.$element.trigger("slid.bs.carousel")),f&&this.cycle(),this)};var c=a.fn.carousel;a.fn.carousel=function(c){return this.each(function(){var d=a(this),e=d.data("bs.carousel"),f=a.extend({},b.DEFAULTS,d.data(),"object"==typeof c&&c),g="string"==typeof c?c:f.slide;e||d.data("bs.carousel",e=new b(this,f)),"number"==typeof c?e.to(c):g?e[g]():f.interval&&e.pause().cycle()})},a.fn.carousel.Constructor=b,a.fn.carousel.noConflict=function(){return a.fn.carousel=c,this},a(document).on("click.bs.carousel.data-api","[data-slide], [data-slide-to]",function(b){var c,d=a(this),e=a(d.attr("data-target")||(c=d.attr("href"))&&c.replace(/.*(?=#[^\s]+$)/,"")),f=a.extend({},e.data(),d.data()),g=d.attr("data-slide-to");g&&(f.interval=!1),e.carousel(f),(g=d.attr("data-slide-to"))&&e.data("bs.carousel").to(g),b.preventDefault()}),a(window).on("load",function(){a('[data-ride="carousel"]').each(function(){var b=a(this);b.carousel(b.data())})})}(jQuery),+function(a){var b=function(c,d){this.$element=a(c),this.options=a.extend({},b.DEFAULTS,d),this.transitioning=null,this.options.parent&&(this.$parent=a(this.options.parent)),this.options.toggle&&this.toggle()};b.DEFAULTS={toggle:!0},b.prototype.dimension=function(){var a=this.$element.hasClass("width");return a?"width":"height"},b.prototype.show=function(){if(!this.transitioning&&!this.$element.hasClass("in")){var b=a.Event("show.bs.collapse");if(this.$element.trigger(b),!b.isDefaultPrevented()){var c=this.$parent&&this.$parent.find("> .panel > .in");if(c&&c.length){var d=c.data("bs.collapse");if(d&&d.transitioning)return;c.collapse("hide"),d||c.data("bs.collapse",null)}var e=this.dimension();this.$element.removeClass("collapse").addClass("collapsing")[e](0),this.transitioning=1;var f=function(){this.$element.removeClass("collapsing").addClass("collapse in")[e]("auto"),this.transitioning=0,this.$element.trigger("shown.bs.collapse")};if(!a.support.transition)return f.call(this);var g=a.camelCase(["scroll",e].join("-"));this.$element.one(a.support.transition.end,a.proxy(f,this)).emulateTransitionEnd(350)[e](this.$element[0][g])}}},b.prototype.hide=function(){if(!this.transitioning&&this.$element.hasClass("in")){var b=a.Event("hide.bs.collapse");if(this.$element.trigger(b),!b.isDefaultPrevented()){var c=this.dimension();this.$element[c](this.$element[c]())[0].offsetHeight,this.$element.addClass("collapsing").removeClass("collapse").removeClass("in"),this.transitioning=1;var d=function(){this.transitioning=0,this.$element.trigger("hidden.bs.collapse").removeClass("collapsing").addClass("collapse")};return a.support.transition?void this.$element[c](0).one(a.support.transition.end,a.proxy(d,this)).emulateTransitionEnd(350):d.call(this)}}},b.prototype.toggle=function(){this[this.$element.hasClass("in")?"hide":"show"]()};var c=a.fn.collapse;a.fn.collapse=function(c){return this.each(function(){var d=a(this),e=d.data("bs.collapse"),f=a.extend({},b.DEFAULTS,d.data(),"object"==typeof c&&c);!e&&f.toggle&&"show"==c&&(c=!c),e||d.data("bs.collapse",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.collapse.Constructor=b,a.fn.collapse.noConflict=function(){return a.fn.collapse=c,this},a(document).on("click.bs.collapse.data-api","[data-toggle=collapse]",function(b){var c,d=a(this),e=d.attr("data-target")||b.preventDefault()||(c=d.attr("href"))&&c.replace(/.*(?=#[^\s]+$)/,""),f=a(e),g=f.data("bs.collapse"),h=g?"toggle":d.data(),i=d.attr("data-parent"),j=i&&a(i);g&&g.transitioning||(j&&j.find('[data-toggle=collapse][data-parent="'+i+'"]').not(d).addClass("collapsed"),d[f.hasClass("in")?"addClass":"removeClass"]("collapsed")),f.collapse(h)})}(jQuery),+function(a){function b(b){a(d).remove(),a(e).each(function(){var d=c(a(this)),e={relatedTarget:this};d.hasClass("open")&&(d.trigger(b=a.Event("hide.bs.dropdown",e)),b.isDefaultPrevented()||d.removeClass("open").trigger("hidden.bs.dropdown",e))})}function c(b){var c=b.attr("data-target");c||(c=b.attr("href"),c=c&&/#[A-Za-z]/.test(c)&&c.replace(/.*(?=#[^\s]*$)/,""));var d=c&&a(c);return d&&d.length?d:b.parent()}var d=".dropdown-backdrop",e="[data-toggle=dropdown]",f=function(b){a(b).on("click.bs.dropdown",this.toggle)};f.prototype.toggle=function(d){var e=a(this);if(!e.is(".disabled, :disabled")){var f=c(e),g=f.hasClass("open");if(b(),!g){"ontouchstart"in document.documentElement&&!f.closest(".navbar-nav").length&&a('<div class="dropdown-backdrop"/>').insertAfter(a(this)).on("click",b);var h={relatedTarget:this};if(f.trigger(d=a.Event("show.bs.dropdown",h)),d.isDefaultPrevented())return;f.toggleClass("open").trigger("shown.bs.dropdown",h),e.focus()}return!1}},f.prototype.keydown=function(b){if(/(38|40|27)/.test(b.keyCode)){var d=a(this);if(b.preventDefault(),b.stopPropagation(),!d.is(".disabled, :disabled")){var f=c(d),g=f.hasClass("open");if(!g||g&&27==b.keyCode)return 27==b.which&&f.find(e).focus(),d.click();var h=" li:not(.divider):visible a",i=f.find("[role=menu]"+h+", [role=listbox]"+h);if(i.length){var j=i.index(i.filter(":focus"));38==b.keyCode&&j>0&&j--,40==b.keyCode&&j<i.length-1&&j++,~j||(j=0),i.eq(j).focus()}}}};var g=a.fn.dropdown;a.fn.dropdown=function(b){return this.each(function(){var c=a(this),d=c.data("bs.dropdown");d||c.data("bs.dropdown",d=new f(this)),"string"==typeof b&&d[b].call(c)})},a.fn.dropdown.Constructor=f,a.fn.dropdown.noConflict=function(){return a.fn.dropdown=g,this},a(document).on("click.bs.dropdown.data-api",b).on("click.bs.dropdown.data-api",".dropdown form",function(a){a.stopPropagation()}).on("click.bs.dropdown.data-api",e,f.prototype.toggle).on("keydown.bs.dropdown.data-api",e+", [role=menu], [role=listbox]",f.prototype.keydown)}(jQuery),+function(a){var b=function(b,c){this.options=c,this.$element=a(b),this.$backdrop=this.isShown=null,this.options.remote&&this.$element.find(".modal-content").load(this.options.remote,a.proxy(function(){this.$element.trigger("loaded.bs.modal")},this))};b.DEFAULTS={backdrop:!0,keyboard:!0,show:!0},b.prototype.toggle=function(a){return this[this.isShown?"hide":"show"](a)},b.prototype.show=function(b){var c=this,d=a.Event("show.bs.modal",{relatedTarget:b});this.$element.trigger(d),this.isShown||d.isDefaultPrevented()||(this.isShown=!0,this.escape(),this.$element.on("click.dismiss.bs.modal",'[data-dismiss="modal"]',a.proxy(this.hide,this)),this.backdrop(function(){var d=a.support.transition&&c.$element.hasClass("fade");c.$element.parent().length||c.$element.appendTo(document.body),c.$element.show().scrollTop(0),d&&c.$element[0].offsetWidth,c.$element.addClass("in").attr("aria-hidden",!1),c.enforceFocus();var e=a.Event("shown.bs.modal",{relatedTarget:b});d?c.$element.find(".modal-dialog").one(a.support.transition.end,function(){c.$element.focus().trigger(e)}).emulateTransitionEnd(300):c.$element.focus().trigger(e)}))},b.prototype.hide=function(b){b&&b.preventDefault(),b=a.Event("hide.bs.modal"),this.$element.trigger(b),this.isShown&&!b.isDefaultPrevented()&&(this.isShown=!1,this.escape(),a(document).off("focusin.bs.modal"),this.$element.removeClass("in").attr("aria-hidden",!0).off("click.dismiss.bs.modal"),a.support.transition&&this.$element.hasClass("fade")?this.$element.one(a.support.transition.end,a.proxy(this.hideModal,this)).emulateTransitionEnd(300):this.hideModal())},b.prototype.enforceFocus=function(){a(document).off("focusin.bs.modal").on("focusin.bs.modal",a.proxy(function(a){this.$element[0]===a.target||this.$element.has(a.target).length||this.$element.focus()},this))},b.prototype.escape=function(){this.isShown&&this.options.keyboard?this.$element.on("keyup.dismiss.bs.modal",a.proxy(function(a){27==a.which&&this.hide()},this)):this.isShown||this.$element.off("keyup.dismiss.bs.modal")},b.prototype.hideModal=function(){var a=this;this.$element.hide(),this.backdrop(function(){a.removeBackdrop(),a.$element.trigger("hidden.bs.modal")})},b.prototype.removeBackdrop=function(){this.$backdrop&&this.$backdrop.remove(),this.$backdrop=null},b.prototype.backdrop=function(b){var c=this.$element.hasClass("fade")?"fade":"";if(this.isShown&&this.options.backdrop){var d=a.support.transition&&c;if(this.$backdrop=a('<div class="modal-backdrop '+c+'" />').appendTo(document.body),this.$element.on("click.dismiss.bs.modal",a.proxy(function(a){a.target===a.currentTarget&&("static"==this.options.backdrop?this.$element[0].focus.call(this.$element[0]):this.hide.call(this))},this)),d&&this.$backdrop[0].offsetWidth,this.$backdrop.addClass("in"),!b)return;d?this.$backdrop.one(a.support.transition.end,b).emulateTransitionEnd(150):b()}else!this.isShown&&this.$backdrop?(this.$backdrop.removeClass("in"),a.support.transition&&this.$element.hasClass("fade")?this.$backdrop.one(a.support.transition.end,b).emulateTransitionEnd(150):b()):b&&b()};var c=a.fn.modal;a.fn.modal=function(c,d){return this.each(function(){var e=a(this),f=e.data("bs.modal"),g=a.extend({},b.DEFAULTS,e.data(),"object"==typeof c&&c);f||e.data("bs.modal",f=new b(this,g)),"string"==typeof c?f[c](d):g.show&&f.show(d)})},a.fn.modal.Constructor=b,a.fn.modal.noConflict=function(){return a.fn.modal=c,this},a(document).on("click.bs.modal.data-api",'[data-toggle="modal"]',function(b){var c=a(this),d=c.attr("href"),e=a(c.attr("data-target")||d&&d.replace(/.*(?=#[^\s]+$)/,"")),f=e.data("bs.modal")?"toggle":a.extend({remote:!/#/.test(d)&&d},e.data(),c.data());c.is("a")&&b.preventDefault(),e.modal(f,this).one("hide",function(){c.is(":visible")&&c.focus()})}),a(document).on("show.bs.modal",".modal",function(){a(document.body).addClass("modal-open")}).on("hidden.bs.modal",".modal",function(){a(document.body).removeClass("modal-open")})}(jQuery),+function(a){var b=function(a,b){this.type=this.options=this.enabled=this.timeout=this.hoverState=this.$element=null,this.init("tooltip",a,b)};b.DEFAULTS={animation:!0,placement:"top",selector:!1,template:'<div class="tooltip"><div class="tooltip-arrow"></div><div class="tooltip-inner"></div></div>',trigger:"hover focus",title:"",delay:0,html:!1,container:!1},b.prototype.init=function(b,c,d){this.enabled=!0,this.type=b,this.$element=a(c),this.options=this.getOptions(d);for(var e=this.options.trigger.split(" "),f=e.length;f--;){var g=e[f];if("click"==g)this.$element.on("click."+this.type,this.options.selector,a.proxy(this.toggle,this));else if("manual"!=g){var h="hover"==g?"mouseenter":"focusin",i="hover"==g?"mouseleave":"focusout";this.$element.on(h+"."+this.type,this.options.selector,a.proxy(this.enter,this)),this.$element.on(i+"."+this.type,this.options.selector,a.proxy(this.leave,this))}}this.options.selector?this._options=a.extend({},this.options,{trigger:"manual",selector:""}):this.fixTitle()},b.prototype.getDefaults=function(){return b.DEFAULTS},b.prototype.getOptions=function(b){return b=a.extend({},this.getDefaults(),this.$element.data(),b),b.delay&&"number"==typeof b.delay&&(b.delay={show:b.delay,hide:b.delay}),b},b.prototype.getDelegateOptions=function(){var b={},c=this.getDefaults();return this._options&&a.each(this._options,function(a,d){c[a]!=d&&(b[a]=d)}),b},b.prototype.enter=function(b){var c=b instanceof this.constructor?b:a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type);return clearTimeout(c.timeout),c.hoverState="in",c.options.delay&&c.options.delay.show?void(c.timeout=setTimeout(function(){"in"==c.hoverState&&c.show()},c.options.delay.show)):c.show()},b.prototype.leave=function(b){var c=b instanceof this.constructor?b:a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type);return clearTimeout(c.timeout),c.hoverState="out",c.options.delay&&c.options.delay.hide?void(c.timeout=setTimeout(function(){"out"==c.hoverState&&c.hide()},c.options.delay.hide)):c.hide()},b.prototype.show=function(){var b=a.Event("show.bs."+this.type);if(this.hasContent()&&this.enabled){if(this.$element.trigger(b),b.isDefaultPrevented())return;var c=this,d=this.tip();this.setContent(),this.options.animation&&d.addClass("fade");var e="function"==typeof this.options.placement?this.options.placement.call(this,d[0],this.$element[0]):this.options.placement,f=/\s?auto?\s?/i,g=f.test(e);g&&(e=e.replace(f,"")||"top"),d.detach().css({top:0,left:0,display:"block"}).addClass(e),this.options.container?d.appendTo(this.options.container):d.insertAfter(this.$element);var h=this.getPosition(),i=d[0].offsetWidth,j=d[0].offsetHeight;if(g){var k=this.$element.parent(),l=e,m=document.documentElement.scrollTop||document.body.scrollTop,n="body"==this.options.container?window.innerWidth:k.outerWidth(),o="body"==this.options.container?window.innerHeight:k.outerHeight(),p="body"==this.options.container?0:k.offset().left;e="bottom"==e&&h.top+h.height+j-m>o?"top":"top"==e&&h.top-m-j<0?"bottom":"right"==e&&h.right+i>n?"left":"left"==e&&h.left-i<p?"right":e,d.removeClass(l).addClass(e)}var q=this.getCalculatedOffset(e,h,i,j);this.applyPlacement(q,e),this.hoverState=null;var r=function(){c.$element.trigger("shown.bs."+c.type)};a.support.transition&&this.$tip.hasClass("fade")?d.one(a.support.transition.end,r).emulateTransitionEnd(150):r()}},b.prototype.applyPlacement=function(b,c){var d,e=this.tip(),f=e[0].offsetWidth,g=e[0].offsetHeight,h=parseInt(e.css("margin-top"),10),i=parseInt(e.css("margin-left"),10);isNaN(h)&&(h=0),isNaN(i)&&(i=0),b.top=b.top+h,b.left=b.left+i,a.offset.setOffset(e[0],a.extend({using:function(a){e.css({top:Math.round(a.top),left:Math.round(a.left)})}},b),0),e.addClass("in");var j=e[0].offsetWidth,k=e[0].offsetHeight;if("top"==c&&k!=g&&(d=!0,b.top=b.top+g-k),/bottom|top/.test(c)){var l=0;b.left<0&&(l=-2*b.left,b.left=0,e.offset(b),j=e[0].offsetWidth,k=e[0].offsetHeight),this.replaceArrow(l-f+j,j,"left")}else this.replaceArrow(k-g,k,"top");d&&e.offset(b)},b.prototype.replaceArrow=function(a,b,c){this.arrow().css(c,a?50*(1-a/b)+"%":"")},b.prototype.setContent=function(){var a=this.tip(),b=this.getTitle();a.find(".tooltip-inner")[this.options.html?"html":"text"](b),a.removeClass("fade in top bottom left right")},b.prototype.hide=function(){function b(){"in"!=c.hoverState&&d.detach(),c.$element.trigger("hidden.bs."+c.type)}var c=this,d=this.tip(),e=a.Event("hide.bs."+this.type);return this.$element.trigger(e),e.isDefaultPrevented()?void 0:(d.removeClass("in"),a.support.transition&&this.$tip.hasClass("fade")?d.one(a.support.transition.end,b).emulateTransitionEnd(150):b(),this.hoverState=null,this)},b.prototype.fixTitle=function(){var a=this.$element;(a.attr("title")||"string"!=typeof a.attr("data-original-title"))&&a.attr("data-original-title",a.attr("title")||"").attr("title","")},b.prototype.hasContent=function(){return this.getTitle()},b.prototype.getPosition=function(){var b=this.$element[0];return a.extend({},"function"==typeof b.getBoundingClientRect?b.getBoundingClientRect():{width:b.offsetWidth,height:b.offsetHeight},this.$element.offset())},b.prototype.getCalculatedOffset=function(a,b,c,d){return"bottom"==a?{top:b.top+b.height,left:b.left+b.width/2-c/2}:"top"==a?{top:b.top-d,left:b.left+b.width/2-c/2}:"left"==a?{top:b.top+b.height/2-d/2,left:b.left-c}:{top:b.top+b.height/2-d/2,left:b.left+b.width}},b.prototype.getTitle=function(){var a,b=this.$element,c=this.options;return a=b.attr("data-original-title")||("function"==typeof c.title?c.title.call(b[0]):c.title)},b.prototype.tip=function(){return this.$tip=this.$tip||a(this.options.template)},b.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".tooltip-arrow")},b.prototype.validate=function(){this.$element[0].parentNode||(this.hide(),this.$element=null,this.options=null)},b.prototype.enable=function(){this.enabled=!0},b.prototype.disable=function(){this.enabled=!1},b.prototype.toggleEnabled=function(){this.enabled=!this.enabled},b.prototype.toggle=function(b){var c=b?a(b.currentTarget)[this.type](this.getDelegateOptions()).data("bs."+this.type):this;c.tip().hasClass("in")?c.leave(c):c.enter(c)},b.prototype.destroy=function(){clearTimeout(this.timeout),this.hide().$element.off("."+this.type).removeData("bs."+this.type)};var c=a.fn.tooltip;a.fn.tooltip=function(c){return this.each(function(){var d=a(this),e=d.data("bs.tooltip"),f="object"==typeof c&&c;(e||"destroy"!=c)&&(e||d.data("bs.tooltip",e=new b(this,f)),"string"==typeof c&&e[c]())})},a.fn.tooltip.Constructor=b,a.fn.tooltip.noConflict=function(){return a.fn.tooltip=c,this}}(jQuery),+function(a){var b=function(a,b){this.init("popover",a,b)};if(!a.fn.tooltip)throw new Error("Popover requires tooltip.js");b.DEFAULTS=a.extend({},a.fn.tooltip.Constructor.DEFAULTS,{placement:"right",trigger:"click",content:"",template:'<div class="popover"><div class="arrow"></div><h3 class="popover-title"></h3><div class="popover-content"></div></div>'}),b.prototype=a.extend({},a.fn.tooltip.Constructor.prototype),b.prototype.constructor=b,b.prototype.getDefaults=function(){return b.DEFAULTS},b.prototype.setContent=function(){var a=this.tip(),b=this.getTitle(),c=this.getContent();a.find(".popover-title")[this.options.html?"html":"text"](b),a.find(".popover-content")[this.options.html?"string"==typeof c?"html":"append":"text"](c),a.removeClass("fade top bottom left right in"),a.find(".popover-title").html()||a.find(".popover-title").hide()},b.prototype.hasContent=function(){return this.getTitle()||this.getContent()},b.prototype.getContent=function(){var a=this.$element,b=this.options;return a.attr("data-content")||("function"==typeof b.content?b.content.call(a[0]):b.content)},b.prototype.arrow=function(){return this.$arrow=this.$arrow||this.tip().find(".arrow")},b.prototype.tip=function(){return this.$tip||(this.$tip=a(this.options.template)),this.$tip};var c=a.fn.popover;a.fn.popover=function(c){return this.each(function(){var d=a(this),e=d.data("bs.popover"),f="object"==typeof c&&c;(e||"destroy"!=c)&&(e||d.data("bs.popover",e=new b(this,f)),"string"==typeof c&&e[c]())})},a.fn.popover.Constructor=b,a.fn.popover.noConflict=function(){return a.fn.popover=c,this}}(jQuery),+function(a){function b(c,d){var e,f=a.proxy(this.process,this);this.$element=a(a(c).is("body")?window:c),this.$body=a("body"),this.$scrollElement=this.$element.on("scroll.bs.scroll-spy.data-api",f),this.options=a.extend({},b.DEFAULTS,d),this.selector=(this.options.target||(e=a(c).attr("href"))&&e.replace(/.*(?=#[^\s]+$)/,"")||"")+" .nav li > a",this.offsets=a([]),this.targets=a([]),this.activeTarget=null,this.refresh(),this.process()}b.DEFAULTS={offset:10},b.prototype.refresh=function(){var b=this.$element[0]==window?"offset":"position";this.offsets=a([]),this.targets=a([]);{var c=this;this.$body.find(this.selector).map(function(){var d=a(this),e=d.data("target")||d.attr("href"),f=/^#./.test(e)&&a(e);return f&&f.length&&f.is(":visible")&&[[f[b]().top+(!a.isWindow(c.$scrollElement.get(0))&&c.$scrollElement.scrollTop()),e]]||null}).sort(function(a,b){return a[0]-b[0]}).each(function(){c.offsets.push(this[0]),c.targets.push(this[1])})}},b.prototype.process=function(){var a,b=this.$scrollElement.scrollTop()+this.options.offset,c=this.$scrollElement[0].scrollHeight||this.$body[0].scrollHeight,d=c-this.$scrollElement.height(),e=this.offsets,f=this.targets,g=this.activeTarget;if(b>=d)return g!=(a=f.last()[0])&&this.activate(a);if(g&&b<=e[0])return g!=(a=f[0])&&this.activate(a);for(a=e.length;a--;)g!=f[a]&&b>=e[a]&&(!e[a+1]||b<=e[a+1])&&this.activate(f[a])},b.prototype.activate=function(b){this.activeTarget=b,a(this.selector).parentsUntil(this.options.target,".active").removeClass("active");var c=this.selector+'[data-target="'+b+'"],'+this.selector+'[href="'+b+'"]',d=a(c).parents("li").addClass("active");d.parent(".dropdown-menu").length&&(d=d.closest("li.dropdown").addClass("active")),d.trigger("activate.bs.scrollspy")};var c=a.fn.scrollspy;a.fn.scrollspy=function(c){return this.each(function(){var d=a(this),e=d.data("bs.scrollspy"),f="object"==typeof c&&c;e||d.data("bs.scrollspy",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.scrollspy.Constructor=b,a.fn.scrollspy.noConflict=function(){return a.fn.scrollspy=c,this},a(window).on("load",function(){a('[data-spy="scroll"]').each(function(){var b=a(this);b.scrollspy(b.data())})})}(jQuery),+function(a){var b=function(b){this.element=a(b)};b.prototype.show=function(){var b=this.element,c=b.closest("ul:not(.dropdown-menu)"),d=b.data("target");if(d||(d=b.attr("href"),d=d&&d.replace(/.*(?=#[^\s]*$)/,"")),!b.parent("li").hasClass("active")){var e=c.find(".active:last a")[0],f=a.Event("show.bs.tab",{relatedTarget:e});if(b.trigger(f),!f.isDefaultPrevented()){var g=a(d);this.activate(b.parent("li"),c),this.activate(g,g.parent(),function(){b.trigger({type:"shown.bs.tab",relatedTarget:e})})}}},b.prototype.activate=function(b,c,d){function e(){f.removeClass("active").find("> .dropdown-menu > .active").removeClass("active"),b.addClass("active"),g?(b[0].offsetWidth,b.addClass("in")):b.removeClass("fade"),b.parent(".dropdown-menu")&&b.closest("li.dropdown").addClass("active"),d&&d()}var f=c.find("> .active"),g=d&&a.support.transition&&f.hasClass("fade");g?f.one(a.support.transition.end,e).emulateTransitionEnd(150):e(),f.removeClass("in")};var c=a.fn.tab;a.fn.tab=function(c){return this.each(function(){var d=a(this),e=d.data("bs.tab");e||d.data("bs.tab",e=new b(this)),"string"==typeof c&&e[c]()})},a.fn.tab.Constructor=b,a.fn.tab.noConflict=function(){return a.fn.tab=c,this},a(document).on("click.bs.tab.data-api",'[data-toggle="tab"], [data-toggle="pill"]',function(b){b.preventDefault(),a(this).tab("show")})}(jQuery),+function(a){var b=function(c,d){this.options=a.extend({},b.DEFAULTS,d),this.$window=a(window).on("scroll.bs.affix.data-api",a.proxy(this.checkPosition,this)).on("click.bs.affix.data-api",a.proxy(this.checkPositionWithEventLoop,this)),this.$element=a(c),this.affixed=this.unpin=this.pinnedOffset=null,this.checkPosition()};b.RESET="affix affix-top affix-bottom",b.DEFAULTS={offset:0},b.prototype.getPinnedOffset=function(){if(this.pinnedOffset)return this.pinnedOffset;this.$element.removeClass(b.RESET).addClass("affix");var a=this.$window.scrollTop(),c=this.$element.offset();return this.pinnedOffset=c.top-a},b.prototype.checkPositionWithEventLoop=function(){setTimeout(a.proxy(this.checkPosition,this),1)},b.prototype.checkPosition=function(){if(this.$element.is(":visible")){var c=a(document).height(),d=this.$window.scrollTop(),e=this.$element.offset(),f=this.options.offset,g=f.top,h=f.bottom;"top"==this.affixed&&(e.top+=d),"object"!=typeof f&&(h=g=f),"function"==typeof g&&(g=f.top(this.$element)),"function"==typeof h&&(h=f.bottom(this.$element));var i=null!=this.unpin&&d+this.unpin<=e.top?!1:null!=h&&e.top+this.$element.height()>=c-h?"bottom":null!=g&&g>=d?"top":!1;if(this.affixed!==i){this.unpin&&this.$element.css("top","");var j="affix"+(i?"-"+i:""),k=a.Event(j+".bs.affix");this.$element.trigger(k),k.isDefaultPrevented()||(this.affixed=i,this.unpin="bottom"==i?this.getPinnedOffset():null,this.$element.removeClass(b.RESET).addClass(j).trigger(a.Event(j.replace("affix","affixed"))),"bottom"==i&&this.$element.offset({top:c-h-this.$element.height()}))}}};var c=a.fn.affix;a.fn.affix=function(c){return this.each(function(){var d=a(this),e=d.data("bs.affix"),f="object"==typeof c&&c;e||d.data("bs.affix",e=new b(this,f)),"string"==typeof c&&e[c]()})},a.fn.affix.Constructor=b,a.fn.affix.noConflict=function(){return a.fn.affix=c,this},a(window).on("load",function(){a('[data-spy="affix"]').each(function(){var b=a(this),c=b.data();c.offset=c.offset||{},c.offsetBottom&&(c.offset.bottom=c.offsetBottom),c.offsetTop&&(c.offset.top=c.offsetTop),b.affix(c)})})}(jQuery);
|
|
define("bootstrap", ["jquery"], function(){});
|
|
|
|
/*!
|
|
* Knockout JavaScript library v3.3.0
|
|
* (c) Steven Sanderson - http://knockoutjs.com/
|
|
* License: MIT (http://www.opensource.org/licenses/mit-license.php)
|
|
*/
|
|
|
|
(function(){
|
|
var DEBUG=true;
|
|
(function(undefined){
|
|
// (0, eval)('this') is a robust way of getting a reference to the global object
|
|
// For details, see http://stackoverflow.com/questions/14119988/return-this-0-evalthis/14120023#14120023
|
|
var window = this || (0, eval)('this'),
|
|
document = window['document'],
|
|
navigator = window['navigator'],
|
|
jQueryInstance = window["jQuery"],
|
|
JSON = window["JSON"];
|
|
(function(factory) {
|
|
// Support three module loading scenarios
|
|
if (typeof define === 'function' && define['amd']) {
|
|
// [1] AMD anonymous module
|
|
define('knockout',['exports', 'require'], factory);
|
|
} else if (typeof require === 'function' && typeof exports === 'object' && typeof module === 'object') {
|
|
// [2] CommonJS/Node.js
|
|
factory(module['exports'] || exports); // module.exports is for Node.js
|
|
} else {
|
|
// [3] No module loader (plain <script> tag) - put directly in global namespace
|
|
factory(window['ko'] = {});
|
|
}
|
|
}(function(koExports, amdRequire){
|
|
// Internally, all KO objects are attached to koExports (even the non-exported ones whose names will be minified by the closure compiler).
|
|
// In the future, the following "ko" variable may be made distinct from "koExports" so that private objects are not externally reachable.
|
|
var ko = typeof koExports !== 'undefined' ? koExports : {};
|
|
// Google Closure Compiler helpers (used only to make the minified file smaller)
|
|
ko.exportSymbol = function(koPath, object) {
|
|
var tokens = koPath.split(".");
|
|
|
|
// In the future, "ko" may become distinct from "koExports" (so that non-exported objects are not reachable)
|
|
// At that point, "target" would be set to: (typeof koExports !== "undefined" ? koExports : ko)
|
|
var target = ko;
|
|
|
|
for (var i = 0; i < tokens.length - 1; i++)
|
|
target = target[tokens[i]];
|
|
target[tokens[tokens.length - 1]] = object;
|
|
};
|
|
ko.exportProperty = function(owner, publicName, object) {
|
|
owner[publicName] = object;
|
|
};
|
|
ko.version = "3.3.0";
|
|
|
|
ko.exportSymbol('version', ko.version);
|
|
ko.utils = (function () {
|
|
function objectForEach(obj, action) {
|
|
for (var prop in obj) {
|
|
if (obj.hasOwnProperty(prop)) {
|
|
action(prop, obj[prop]);
|
|
}
|
|
}
|
|
}
|
|
|
|
function extend(target, source) {
|
|
if (source) {
|
|
for(var prop in source) {
|
|
if(source.hasOwnProperty(prop)) {
|
|
target[prop] = source[prop];
|
|
}
|
|
}
|
|
}
|
|
return target;
|
|
}
|
|
|
|
function setPrototypeOf(obj, proto) {
|
|
obj.__proto__ = proto;
|
|
return obj;
|
|
}
|
|
|
|
var canSetPrototype = ({ __proto__: [] } instanceof Array);
|
|
|
|
// Represent the known event types in a compact way, then at runtime transform it into a hash with event name as key (for fast lookup)
|
|
var knownEvents = {}, knownEventTypesByEventName = {};
|
|
var keyEventTypeName = (navigator && /Firefox\/2/i.test(navigator.userAgent)) ? 'KeyboardEvent' : 'UIEvents';
|
|
knownEvents[keyEventTypeName] = ['keyup', 'keydown', 'keypress'];
|
|
knownEvents['MouseEvents'] = ['click', 'dblclick', 'mousedown', 'mouseup', 'mousemove', 'mouseover', 'mouseout', 'mouseenter', 'mouseleave'];
|
|
objectForEach(knownEvents, function(eventType, knownEventsForType) {
|
|
if (knownEventsForType.length) {
|
|
for (var i = 0, j = knownEventsForType.length; i < j; i++)
|
|
knownEventTypesByEventName[knownEventsForType[i]] = eventType;
|
|
}
|
|
});
|
|
var eventsThatMustBeRegisteredUsingAttachEvent = { 'propertychange': true }; // Workaround for an IE9 issue - https://github.com/SteveSanderson/knockout/issues/406
|
|
|
|
// Detect IE versions for bug workarounds (uses IE conditionals, not UA string, for robustness)
|
|
// Note that, since IE 10 does not support conditional comments, the following logic only detects IE < 10.
|
|
// Currently this is by design, since IE 10+ behaves correctly when treated as a standard browser.
|
|
// If there is a future need to detect specific versions of IE10+, we will amend this.
|
|
var ieVersion = document && (function() {
|
|
var version = 3, div = document.createElement('div'), iElems = div.getElementsByTagName('i');
|
|
|
|
// Keep constructing conditional HTML blocks until we hit one that resolves to an empty fragment
|
|
while (
|
|
div.innerHTML = '<!--[if gt IE ' + (++version) + ']><i></i><![endif]-->',
|
|
iElems[0]
|
|
) {}
|
|
return version > 4 ? version : undefined;
|
|
}());
|
|
var isIe6 = ieVersion === 6,
|
|
isIe7 = ieVersion === 7;
|
|
|
|
function isClickOnCheckableElement(element, eventType) {
|
|
if ((ko.utils.tagNameLower(element) !== "input") || !element.type) return false;
|
|
if (eventType.toLowerCase() != "click") return false;
|
|
var inputType = element.type;
|
|
return (inputType == "checkbox") || (inputType == "radio");
|
|
}
|
|
|
|
// For details on the pattern for changing node classes
|
|
// see: https://github.com/knockout/knockout/issues/1597
|
|
var cssClassNameRegex = /\S+/g;
|
|
|
|
function toggleDomNodeCssClass(node, classNames, shouldHaveClass) {
|
|
var addOrRemoveFn;
|
|
if (classNames) {
|
|
if (typeof node.classList === 'object') {
|
|
addOrRemoveFn = node.classList[shouldHaveClass ? 'add' : 'remove'];
|
|
ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {
|
|
addOrRemoveFn.call(node.classList, className);
|
|
});
|
|
} else if (typeof node.className['baseVal'] === 'string') {
|
|
// SVG tag .classNames is an SVGAnimatedString instance
|
|
toggleObjectClassPropertyString(node.className, 'baseVal', classNames, shouldHaveClass);
|
|
} else {
|
|
// node.className ought to be a string.
|
|
toggleObjectClassPropertyString(node, 'className', classNames, shouldHaveClass);
|
|
}
|
|
}
|
|
}
|
|
|
|
function toggleObjectClassPropertyString(obj, prop, classNames, shouldHaveClass) {
|
|
// obj/prop is either a node/'className' or a SVGAnimatedString/'baseVal'.
|
|
var currentClassNames = obj[prop].match(cssClassNameRegex) || [];
|
|
ko.utils.arrayForEach(classNames.match(cssClassNameRegex), function(className) {
|
|
ko.utils.addOrRemoveItem(currentClassNames, className, shouldHaveClass);
|
|
});
|
|
obj[prop] = currentClassNames.join(" ");
|
|
}
|
|
|
|
return {
|
|
fieldsIncludedWithJsonPost: ['authenticity_token', /^__RequestVerificationToken(_.*)?$/],
|
|
|
|
arrayForEach: function (array, action) {
|
|
for (var i = 0, j = array.length; i < j; i++)
|
|
action(array[i], i);
|
|
},
|
|
|
|
arrayIndexOf: function (array, item) {
|
|
if (typeof Array.prototype.indexOf == "function")
|
|
return Array.prototype.indexOf.call(array, item);
|
|
for (var i = 0, j = array.length; i < j; i++)
|
|
if (array[i] === item)
|
|
return i;
|
|
return -1;
|
|
},
|
|
|
|
arrayFirst: function (array, predicate, predicateOwner) {
|
|
for (var i = 0, j = array.length; i < j; i++)
|
|
if (predicate.call(predicateOwner, array[i], i))
|
|
return array[i];
|
|
return null;
|
|
},
|
|
|
|
arrayRemoveItem: function (array, itemToRemove) {
|
|
var index = ko.utils.arrayIndexOf(array, itemToRemove);
|
|
if (index > 0) {
|
|
array.splice(index, 1);
|
|
}
|
|
else if (index === 0) {
|
|
array.shift();
|
|
}
|
|
},
|
|
|
|
arrayGetDistinctValues: function (array) {
|
|
array = array || [];
|
|
var result = [];
|
|
for (var i = 0, j = array.length; i < j; i++) {
|
|
if (ko.utils.arrayIndexOf(result, array[i]) < 0)
|
|
result.push(array[i]);
|
|
}
|
|
return result;
|
|
},
|
|
|
|
arrayMap: function (array, mapping) {
|
|
array = array || [];
|
|
var result = [];
|
|
for (var i = 0, j = array.length; i < j; i++)
|
|
result.push(mapping(array[i], i));
|
|
return result;
|
|
},
|
|
|
|
arrayFilter: function (array, predicate) {
|
|
array = array || [];
|
|
var result = [];
|
|
for (var i = 0, j = array.length; i < j; i++)
|
|
if (predicate(array[i], i))
|
|
result.push(array[i]);
|
|
return result;
|
|
},
|
|
|
|
arrayPushAll: function (array, valuesToPush) {
|
|
if (valuesToPush instanceof Array)
|
|
array.push.apply(array, valuesToPush);
|
|
else
|
|
for (var i = 0, j = valuesToPush.length; i < j; i++)
|
|
array.push(valuesToPush[i]);
|
|
return array;
|
|
},
|
|
|
|
addOrRemoveItem: function(array, value, included) {
|
|
var existingEntryIndex = ko.utils.arrayIndexOf(ko.utils.peekObservable(array), value);
|
|
if (existingEntryIndex < 0) {
|
|
if (included)
|
|
array.push(value);
|
|
} else {
|
|
if (!included)
|
|
array.splice(existingEntryIndex, 1);
|
|
}
|
|
},
|
|
|
|
canSetPrototype: canSetPrototype,
|
|
|
|
extend: extend,
|
|
|
|
setPrototypeOf: setPrototypeOf,
|
|
|
|
setPrototypeOfOrExtend: canSetPrototype ? setPrototypeOf : extend,
|
|
|
|
objectForEach: objectForEach,
|
|
|
|
objectMap: function(source, mapping) {
|
|
if (!source)
|
|
return source;
|
|
var target = {};
|
|
for (var prop in source) {
|
|
if (source.hasOwnProperty(prop)) {
|
|
target[prop] = mapping(source[prop], prop, source);
|
|
}
|
|
}
|
|
return target;
|
|
},
|
|
|
|
emptyDomNode: function (domNode) {
|
|
while (domNode.firstChild) {
|
|
ko.removeNode(domNode.firstChild);
|
|
}
|
|
},
|
|
|
|
moveCleanedNodesToContainerElement: function(nodes) {
|
|
// Ensure it's a real array, as we're about to reparent the nodes and
|
|
// we don't want the underlying collection to change while we're doing that.
|
|
var nodesArray = ko.utils.makeArray(nodes);
|
|
var templateDocument = (nodesArray[0] && nodesArray[0].ownerDocument) || document;
|
|
|
|
var container = templateDocument.createElement('div');
|
|
for (var i = 0, j = nodesArray.length; i < j; i++) {
|
|
container.appendChild(ko.cleanNode(nodesArray[i]));
|
|
}
|
|
return container;
|
|
},
|
|
|
|
cloneNodes: function (nodesArray, shouldCleanNodes) {
|
|
for (var i = 0, j = nodesArray.length, newNodesArray = []; i < j; i++) {
|
|
var clonedNode = nodesArray[i].cloneNode(true);
|
|
newNodesArray.push(shouldCleanNodes ? ko.cleanNode(clonedNode) : clonedNode);
|
|
}
|
|
return newNodesArray;
|
|
},
|
|
|
|
setDomNodeChildren: function (domNode, childNodes) {
|
|
ko.utils.emptyDomNode(domNode);
|
|
if (childNodes) {
|
|
for (var i = 0, j = childNodes.length; i < j; i++)
|
|
domNode.appendChild(childNodes[i]);
|
|
}
|
|
},
|
|
|
|
replaceDomNodes: function (nodeToReplaceOrNodeArray, newNodesArray) {
|
|
var nodesToReplaceArray = nodeToReplaceOrNodeArray.nodeType ? [nodeToReplaceOrNodeArray] : nodeToReplaceOrNodeArray;
|
|
if (nodesToReplaceArray.length > 0) {
|
|
var insertionPoint = nodesToReplaceArray[0];
|
|
var parent = insertionPoint.parentNode;
|
|
for (var i = 0, j = newNodesArray.length; i < j; i++)
|
|
parent.insertBefore(newNodesArray[i], insertionPoint);
|
|
for (var i = 0, j = nodesToReplaceArray.length; i < j; i++) {
|
|
ko.removeNode(nodesToReplaceArray[i]);
|
|
}
|
|
}
|
|
},
|
|
|
|
fixUpContinuousNodeArray: function(continuousNodeArray, parentNode) {
|
|
// Before acting on a set of nodes that were previously outputted by a template function, we have to reconcile
|
|
// them against what is in the DOM right now. It may be that some of the nodes have already been removed, or that
|
|
// new nodes might have been inserted in the middle, for example by a binding. Also, there may previously have been
|
|
// leading comment nodes (created by rewritten string-based templates) that have since been removed during binding.
|
|
// So, this function translates the old "map" output array into its best guess of the set of current DOM nodes.
|
|
//
|
|
// Rules:
|
|
// [A] Any leading nodes that have been removed should be ignored
|
|
// These most likely correspond to memoization nodes that were already removed during binding
|
|
// See https://github.com/SteveSanderson/knockout/pull/440
|
|
// [B] We want to output a continuous series of nodes. So, ignore any nodes that have already been removed,
|
|
// and include any nodes that have been inserted among the previous collection
|
|
|
|
if (continuousNodeArray.length) {
|
|
// The parent node can be a virtual element; so get the real parent node
|
|
parentNode = (parentNode.nodeType === 8 && parentNode.parentNode) || parentNode;
|
|
|
|
// Rule [A]
|
|
while (continuousNodeArray.length && continuousNodeArray[0].parentNode !== parentNode)
|
|
continuousNodeArray.splice(0, 1);
|
|
|
|
// Rule [B]
|
|
if (continuousNodeArray.length > 1) {
|
|
var current = continuousNodeArray[0], last = continuousNodeArray[continuousNodeArray.length - 1];
|
|
// Replace with the actual new continuous node set
|
|
continuousNodeArray.length = 0;
|
|
while (current !== last) {
|
|
continuousNodeArray.push(current);
|
|
current = current.nextSibling;
|
|
if (!current) // Won't happen, except if the developer has manually removed some DOM elements (then we're in an undefined scenario)
|
|
return;
|
|
}
|
|
continuousNodeArray.push(last);
|
|
}
|
|
}
|
|
return continuousNodeArray;
|
|
},
|
|
|
|
setOptionNodeSelectionState: function (optionNode, isSelected) {
|
|
// IE6 sometimes throws "unknown error" if you try to write to .selected directly, whereas Firefox struggles with setAttribute. Pick one based on browser.
|
|
if (ieVersion < 7)
|
|
optionNode.setAttribute("selected", isSelected);
|
|
else
|
|
optionNode.selected = isSelected;
|
|
},
|
|
|
|
stringTrim: function (string) {
|
|
return string === null || string === undefined ? '' :
|
|
string.trim ?
|
|
string.trim() :
|
|
string.toString().replace(/^[\s\xa0]+|[\s\xa0]+$/g, '');
|
|
},
|
|
|
|
stringStartsWith: function (string, startsWith) {
|
|
string = string || "";
|
|
if (startsWith.length > string.length)
|
|
return false;
|
|
return string.substring(0, startsWith.length) === startsWith;
|
|
},
|
|
|
|
domNodeIsContainedBy: function (node, containedByNode) {
|
|
if (node === containedByNode)
|
|
return true;
|
|
if (node.nodeType === 11)
|
|
return false; // Fixes issue #1162 - can't use node.contains for document fragments on IE8
|
|
if (containedByNode.contains)
|
|
return containedByNode.contains(node.nodeType === 3 ? node.parentNode : node);
|
|
if (containedByNode.compareDocumentPosition)
|
|
return (containedByNode.compareDocumentPosition(node) & 16) == 16;
|
|
while (node && node != containedByNode) {
|
|
node = node.parentNode;
|
|
}
|
|
return !!node;
|
|
},
|
|
|
|
domNodeIsAttachedToDocument: function (node) {
|
|
return ko.utils.domNodeIsContainedBy(node, node.ownerDocument.documentElement);
|
|
},
|
|
|
|
anyDomNodeIsAttachedToDocument: function(nodes) {
|
|
return !!ko.utils.arrayFirst(nodes, ko.utils.domNodeIsAttachedToDocument);
|
|
},
|
|
|
|
tagNameLower: function(element) {
|
|
// For HTML elements, tagName will always be upper case; for XHTML elements, it'll be lower case.
|
|
// Possible future optimization: If we know it's an element from an XHTML document (not HTML),
|
|
// we don't need to do the .toLowerCase() as it will always be lower case anyway.
|
|
return element && element.tagName && element.tagName.toLowerCase();
|
|
},
|
|
|
|
registerEventHandler: function (element, eventType, handler) {
|
|
var mustUseAttachEvent = ieVersion && eventsThatMustBeRegisteredUsingAttachEvent[eventType];
|
|
if (!mustUseAttachEvent && jQueryInstance) {
|
|
jQueryInstance(element)['bind'](eventType, handler);
|
|
} else if (!mustUseAttachEvent && typeof element.addEventListener == "function")
|
|
element.addEventListener(eventType, handler, false);
|
|
else if (typeof element.attachEvent != "undefined") {
|
|
var attachEventHandler = function (event) { handler.call(element, event); },
|
|
attachEventName = "on" + eventType;
|
|
element.attachEvent(attachEventName, attachEventHandler);
|
|
|
|
// IE does not dispose attachEvent handlers automatically (unlike with addEventListener)
|
|
// so to avoid leaks, we have to remove them manually. See bug #856
|
|
ko.utils.domNodeDisposal.addDisposeCallback(element, function() {
|
|
element.detachEvent(attachEventName, attachEventHandler);
|
|
});
|
|
} else
|
|
throw new Error("Browser doesn't support addEventListener or attachEvent");
|
|
},
|
|
|
|
triggerEvent: function (element, eventType) {
|
|
if (!(element && element.nodeType))
|
|
throw new Error("element must be a DOM node when calling triggerEvent");
|
|
|
|
// For click events on checkboxes and radio buttons, jQuery toggles the element checked state *after* the
|
|
// event handler runs instead of *before*. (This was fixed in 1.9 for checkboxes but not for radio buttons.)
|
|
// IE doesn't change the checked state when you trigger the click event using "fireEvent".
|
|
// In both cases, we'll use the click method instead.
|
|
var useClickWorkaround = isClickOnCheckableElement(element, eventType);
|
|
|
|
if (jQueryInstance && !useClickWorkaround) {
|
|
jQueryInstance(element)['trigger'](eventType);
|
|
} else if (typeof document.createEvent == "function") {
|
|
if (typeof element.dispatchEvent == "function") {
|
|
var eventCategory = knownEventTypesByEventName[eventType] || "HTMLEvents";
|
|
var event = document.createEvent(eventCategory);
|
|
event.initEvent(eventType, true, true, window, 0, 0, 0, 0, 0, false, false, false, false, 0, element);
|
|
element.dispatchEvent(event);
|
|
}
|
|
else
|
|
throw new Error("The supplied element doesn't support dispatchEvent");
|
|
} else if (useClickWorkaround && element.click) {
|
|
element.click();
|
|
} else if (typeof element.fireEvent != "undefined") {
|
|
element.fireEvent("on" + eventType);
|
|
} else {
|
|
throw new Error("Browser doesn't support triggering events");
|
|
}
|
|
},
|
|
|
|
unwrapObservable: function (value) {
|
|
return ko.isObservable(value) ? value() : value;
|
|
},
|
|
|
|
peekObservable: function (value) {
|
|
return ko.isObservable(value) ? value.peek() : value;
|
|
},
|
|
|
|
toggleDomNodeCssClass: toggleDomNodeCssClass,
|
|
|
|
setTextContent: function(element, textContent) {
|
|
var value = ko.utils.unwrapObservable(textContent);
|
|
if ((value === null) || (value === undefined))
|
|
value = "";
|
|
|
|
// We need there to be exactly one child: a text node.
|
|
// If there are no children, more than one, or if it's not a text node,
|
|
// we'll clear everything and create a single text node.
|
|
var innerTextNode = ko.virtualElements.firstChild(element);
|
|
if (!innerTextNode || innerTextNode.nodeType != 3 || ko.virtualElements.nextSibling(innerTextNode)) {
|
|
ko.virtualElements.setDomNodeChildren(element, [element.ownerDocument.createTextNode(value)]);
|
|
} else {
|
|
innerTextNode.data = value;
|
|
}
|
|
|
|
ko.utils.forceRefresh(element);
|
|
},
|
|
|
|
setElementName: function(element, name) {
|
|
element.name = name;
|
|
|
|
// Workaround IE 6/7 issue
|
|
// - https://github.com/SteveSanderson/knockout/issues/197
|
|
// - http://www.matts411.com/post/setting_the_name_attribute_in_ie_dom/
|
|
if (ieVersion <= 7) {
|
|
try {
|
|
element.mergeAttributes(document.createElement("<input name='" + element.name + "'/>"), false);
|
|
}
|
|
catch(e) {} // For IE9 with doc mode "IE9 Standards" and browser mode "IE9 Compatibility View"
|
|
}
|
|
},
|
|
|
|
forceRefresh: function(node) {
|
|
// Workaround for an IE9 rendering bug - https://github.com/SteveSanderson/knockout/issues/209
|
|
if (ieVersion >= 9) {
|
|
// For text nodes and comment nodes (most likely virtual elements), we will have to refresh the container
|
|
var elem = node.nodeType == 1 ? node : node.parentNode;
|
|
if (elem.style)
|
|
elem.style.zoom = elem.style.zoom;
|
|
}
|
|
},
|
|
|
|
ensureSelectElementIsRenderedCorrectly: function(selectElement) {
|
|
// Workaround for IE9 rendering bug - it doesn't reliably display all the text in dynamically-added select boxes unless you force it to re-render by updating the width.
|
|
// (See https://github.com/SteveSanderson/knockout/issues/312, http://stackoverflow.com/questions/5908494/select-only-shows-first-char-of-selected-option)
|
|
// Also fixes IE7 and IE8 bug that causes selects to be zero width if enclosed by 'if' or 'with'. (See issue #839)
|
|
if (ieVersion) {
|
|
var originalWidth = selectElement.style.width;
|
|
selectElement.style.width = 0;
|
|
selectElement.style.width = originalWidth;
|
|
}
|
|
},
|
|
|
|
range: function (min, max) {
|
|
min = ko.utils.unwrapObservable(min);
|
|
max = ko.utils.unwrapObservable(max);
|
|
var result = [];
|
|
for (var i = min; i <= max; i++)
|
|
result.push(i);
|
|
return result;
|
|
},
|
|
|
|
makeArray: function(arrayLikeObject) {
|
|
var result = [];
|
|
for (var i = 0, j = arrayLikeObject.length; i < j; i++) {
|
|
result.push(arrayLikeObject[i]);
|
|
};
|
|
return result;
|
|
},
|
|
|
|
isIe6 : isIe6,
|
|
isIe7 : isIe7,
|
|
ieVersion : ieVersion,
|
|
|
|
getFormFields: function(form, fieldName) {
|
|
var fields = ko.utils.makeArray(form.getElementsByTagName("input")).concat(ko.utils.makeArray(form.getElementsByTagName("textarea")));
|
|
var isMatchingField = (typeof fieldName == 'string')
|
|
? function(field) { return field.name === fieldName }
|
|
: function(field) { return fieldName.test(field.name) }; // Treat fieldName as regex or object containing predicate
|
|
var matches = [];
|
|
for (var i = fields.length - 1; i >= 0; i--) {
|
|
if (isMatchingField(fields[i]))
|
|
matches.push(fields[i]);
|
|
};
|
|
return matches;
|
|
},
|
|
|
|
parseJson: function (jsonString) {
|
|
if (typeof jsonString == "string") {
|
|
jsonString = ko.utils.stringTrim(jsonString);
|
|
if (jsonString) {
|
|
if (JSON && JSON.parse) // Use native parsing where available
|
|
return JSON.parse(jsonString);
|
|
return (new Function("return " + jsonString))(); // Fallback on less safe parsing for older browsers
|
|
}
|
|
}
|
|
return null;
|
|
},
|
|
|
|
stringifyJson: function (data, replacer, space) { // replacer and space are optional
|
|
if (!JSON || !JSON.stringify)
|
|
throw new Error("Cannot find JSON.stringify(). Some browsers (e.g., IE < 8) don't support it natively, but you can overcome this by adding a script reference to json2.js, downloadable from http://www.json.org/json2.js");
|
|
return JSON.stringify(ko.utils.unwrapObservable(data), replacer, space);
|
|
},
|
|
|
|
postJson: function (urlOrForm, data, options) {
|
|
options = options || {};
|
|
var params = options['params'] || {};
|
|
var includeFields = options['includeFields'] || this.fieldsIncludedWithJsonPost;
|
|
var url = urlOrForm;
|
|
|
|
// If we were given a form, use its 'action' URL and pick out any requested field values
|
|
if((typeof urlOrForm == 'object') && (ko.utils.tagNameLower(urlOrForm) === "form")) {
|
|
var originalForm = urlOrForm;
|
|
url = originalForm.action;
|
|
for (var i = includeFields.length - 1; i >= 0; i--) {
|
|
var fields = ko.utils.getFormFields(originalForm, includeFields[i]);
|
|
for (var j = fields.length - 1; j >= 0; j--)
|
|
params[fields[j].name] = fields[j].value;
|
|
}
|
|
}
|
|
|
|
data = ko.utils.unwrapObservable(data);
|
|
var form = document.createElement("form");
|
|
form.style.display = "none";
|
|
form.action = url;
|
|
form.method = "post";
|
|
for (var key in data) {
|
|
// Since 'data' this is a model object, we include all properties including those inherited from its prototype
|
|
var input = document.createElement("input");
|
|
input.type = "hidden";
|
|
input.name = key;
|
|
input.value = ko.utils.stringifyJson(ko.utils.unwrapObservable(data[key]));
|
|
form.appendChild(input);
|
|
}
|
|
objectForEach(params, function(key, value) {
|
|
var input = document.createElement("input");
|
|
input.type = "hidden";
|
|
input.name = key;
|
|
input.value = value;
|
|
form.appendChild(input);
|
|
});
|
|
document.body.appendChild(form);
|
|
options['submitter'] ? options['submitter'](form) : form.submit();
|
|
setTimeout(function () { form.parentNode.removeChild(form); }, 0);
|
|
}
|
|
}
|
|
}());
|
|
|
|
ko.exportSymbol('utils', ko.utils);
|
|
ko.exportSymbol('utils.arrayForEach', ko.utils.arrayForEach);
|
|
ko.exportSymbol('utils.arrayFirst', ko.utils.arrayFirst);
|
|
ko.exportSymbol('utils.arrayFilter', ko.utils.arrayFilter);
|
|
ko.exportSymbol('utils.arrayGetDistinctValues', ko.utils.arrayGetDistinctValues);
|
|
ko.exportSymbol('utils.arrayIndexOf', ko.utils.arrayIndexOf);
|
|
ko.exportSymbol('utils.arrayMap', ko.utils.arrayMap);
|
|
ko.exportSymbol('utils.arrayPushAll', ko.utils.arrayPushAll);
|
|
ko.exportSymbol('utils.arrayRemoveItem', ko.utils.arrayRemoveItem);
|
|
ko.exportSymbol('utils.extend', ko.utils.extend);
|
|
ko.exportSymbol('utils.fieldsIncludedWithJsonPost', ko.utils.fieldsIncludedWithJsonPost);
|
|
ko.exportSymbol('utils.getFormFields', ko.utils.getFormFields);
|
|
ko.exportSymbol('utils.peekObservable', ko.utils.peekObservable);
|
|
ko.exportSymbol('utils.postJson', ko.utils.postJson);
|
|
ko.exportSymbol('utils.parseJson', ko.utils.parseJson);
|
|
ko.exportSymbol('utils.registerEventHandler', ko.utils.registerEventHandler);
|
|
ko.exportSymbol('utils.stringifyJson', ko.utils.stringifyJson);
|
|
ko.exportSymbol('utils.range', ko.utils.range);
|
|
ko.exportSymbol('utils.toggleDomNodeCssClass', ko.utils.toggleDomNodeCssClass);
|
|
ko.exportSymbol('utils.triggerEvent', ko.utils.triggerEvent);
|
|
ko.exportSymbol('utils.unwrapObservable', ko.utils.unwrapObservable);
|
|
ko.exportSymbol('utils.objectForEach', ko.utils.objectForEach);
|
|
ko.exportSymbol('utils.addOrRemoveItem', ko.utils.addOrRemoveItem);
|
|
ko.exportSymbol('utils.setTextContent', ko.utils.setTextContent);
|
|
ko.exportSymbol('unwrap', ko.utils.unwrapObservable); // Convenient shorthand, because this is used so commonly
|
|
|
|
if (!Function.prototype['bind']) {
|
|
// Function.prototype.bind is a standard part of ECMAScript 5th Edition (December 2009, http://www.ecma-international.org/publications/files/ECMA-ST/ECMA-262.pdf)
|
|
// In case the browser doesn't implement it natively, provide a JavaScript implementation. This implementation is based on the one in prototype.js
|
|
Function.prototype['bind'] = function (object) {
|
|
var originalFunction = this;
|
|
if (arguments.length === 1) {
|
|
return function () {
|
|
return originalFunction.apply(object, arguments);
|
|
};
|
|
} else {
|
|
var partialArgs = Array.prototype.slice.call(arguments, 1);
|
|
return function () {
|
|
var args = partialArgs.slice(0);
|
|
args.push.apply(args, arguments);
|
|
return originalFunction.apply(object, args);
|
|
};
|
|
}
|
|
};
|
|
}
|
|
|
|
ko.utils.domData = new (function () {
|
|
var uniqueId = 0;
|
|
var dataStoreKeyExpandoPropertyName = "__ko__" + (new Date).getTime();
|
|
var dataStore = {};
|
|
|
|
function getAll(node, createIfNotFound) {
|
|
var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
|
|
var hasExistingDataStore = dataStoreKey && (dataStoreKey !== "null") && dataStore[dataStoreKey];
|
|
if (!hasExistingDataStore) {
|
|
if (!createIfNotFound)
|
|
return undefined;
|
|
dataStoreKey = node[dataStoreKeyExpandoPropertyName] = "ko" + uniqueId++;
|
|
dataStore[dataStoreKey] = {};
|
|
}
|
|
return dataStore[dataStoreKey];
|
|
}
|
|
|
|
return {
|
|
get: function (node, key) {
|
|
var allDataForNode = getAll(node, false);
|
|
return allDataForNode === undefined ? undefined : allDataForNode[key];
|
|
},
|
|
set: function (node, key, value) {
|
|
if (value === undefined) {
|
|
// Make sure we don't actually create a new domData key if we are actually deleting a value
|
|
if (getAll(node, false) === undefined)
|
|
return;
|
|
}
|
|
var allDataForNode = getAll(node, true);
|
|
allDataForNode[key] = value;
|
|
},
|
|
clear: function (node) {
|
|
var dataStoreKey = node[dataStoreKeyExpandoPropertyName];
|
|
if (dataStoreKey) {
|
|
delete dataStore[dataStoreKey];
|
|
node[dataStoreKeyExpandoPropertyName] = null;
|
|
return true; // Exposing "did clean" flag purely so specs can infer whether things have been cleaned up as intended
|
|
}
|
|
return false;
|
|
},
|
|
|
|
nextKey: function () {
|
|
return (uniqueId++) + dataStoreKeyExpandoPropertyName;
|
|
}
|
|
};
|
|
})();
|
|
|
|
ko.exportSymbol('utils.domData', ko.utils.domData);
|
|
ko.exportSymbol('utils.domData.clear', ko.utils.domData.clear); // Exporting only so specs can clear up after themselves fully
|
|
|
|
ko.utils.domNodeDisposal = new (function () {
|
|
var domDataKey = ko.utils.domData.nextKey();
|
|
var cleanableNodeTypes = { 1: true, 8: true, 9: true }; // Element, Comment, Document
|
|
var cleanableNodeTypesWithDescendants = { 1: true, 9: true }; // Element, Document
|
|
|
|
function getDisposeCallbacksCollection(node, createIfNotFound) {
|
|
var allDisposeCallbacks = ko.utils.domData.get(node, domDataKey);
|
|
if ((allDisposeCallbacks === undefined) && createIfNotFound) {
|
|
allDisposeCallbacks = [];
|
|
ko.utils.domData.set(node, domDataKey, allDisposeCallbacks);
|
|
}
|
|
return allDisposeCallbacks;
|
|
}
|
|
function destroyCallbacksCollection(node) {
|
|
ko.utils.domData.set(node, domDataKey, undefined);
|
|
}
|
|
|
|
function cleanSingleNode(node) {
|
|
// Run all the dispose callbacks
|
|
var callbacks = getDisposeCallbacksCollection(node, false);
|
|
if (callbacks) {
|
|
callbacks = callbacks.slice(0); // Clone, as the array may be modified during iteration (typically, callbacks will remove themselves)
|
|
for (var i = 0; i < callbacks.length; i++)
|
|
callbacks[i](node);
|
|
}
|
|
|
|
// Erase the DOM data
|
|
ko.utils.domData.clear(node);
|
|
|
|
// Perform cleanup needed by external libraries (currently only jQuery, but can be extended)
|
|
ko.utils.domNodeDisposal["cleanExternalData"](node);
|
|
|
|
// Clear any immediate-child comment nodes, as these wouldn't have been found by
|
|
// node.getElementsByTagName("*") in cleanNode() (comment nodes aren't elements)
|
|
if (cleanableNodeTypesWithDescendants[node.nodeType])
|
|
cleanImmediateCommentTypeChildren(node);
|
|
}
|
|
|
|
function cleanImmediateCommentTypeChildren(nodeWithChildren) {
|
|
var child, nextChild = nodeWithChildren.firstChild;
|
|
while (child = nextChild) {
|
|
nextChild = child.nextSibling;
|
|
if (child.nodeType === 8)
|
|
cleanSingleNode(child);
|
|
}
|
|
}
|
|
|
|
return {
|
|
addDisposeCallback : function(node, callback) {
|
|
if (typeof callback != "function")
|
|
throw new Error("Callback must be a function");
|
|
getDisposeCallbacksCollection(node, true).push(callback);
|
|
},
|
|
|
|
removeDisposeCallback : function(node, callback) {
|
|
var callbacksCollection = getDisposeCallbacksCollection(node, false);
|
|
if (callbacksCollection) {
|
|
ko.utils.arrayRemoveItem(callbacksCollection, callback);
|
|
if (callbacksCollection.length == 0)
|
|
destroyCallbacksCollection(node);
|
|
}
|
|
},
|
|
|
|
cleanNode : function(node) {
|
|
// First clean this node, where applicable
|
|
if (cleanableNodeTypes[node.nodeType]) {
|
|
cleanSingleNode(node);
|
|
|
|
// ... then its descendants, where applicable
|
|
if (cleanableNodeTypesWithDescendants[node.nodeType]) {
|
|
// Clone the descendants list in case it changes during iteration
|
|
var descendants = [];
|
|
ko.utils.arrayPushAll(descendants, node.getElementsByTagName("*"));
|
|
for (var i = 0, j = descendants.length; i < j; i++)
|
|
cleanSingleNode(descendants[i]);
|
|
}
|
|
}
|
|
return node;
|
|
},
|
|
|
|
removeNode : function(node) {
|
|
ko.cleanNode(node);
|
|
if (node.parentNode)
|
|
node.parentNode.removeChild(node);
|
|
},
|
|
|
|
"cleanExternalData" : function (node) {
|
|
// Special support for jQuery here because it's so commonly used.
|
|
// Many jQuery plugins (including jquery.tmpl) store data using jQuery's equivalent of domData
|
|
// so notify it to tear down any resources associated with the node & descendants here.
|
|
if (jQueryInstance && (typeof jQueryInstance['cleanData'] == "function"))
|
|
jQueryInstance['cleanData']([node]);
|
|
}
|
|
};
|
|
})();
|
|
ko.cleanNode = ko.utils.domNodeDisposal.cleanNode; // Shorthand name for convenience
|
|
ko.removeNode = ko.utils.domNodeDisposal.removeNode; // Shorthand name for convenience
|
|
ko.exportSymbol('cleanNode', ko.cleanNode);
|
|
ko.exportSymbol('removeNode', ko.removeNode);
|
|
ko.exportSymbol('utils.domNodeDisposal', ko.utils.domNodeDisposal);
|
|
ko.exportSymbol('utils.domNodeDisposal.addDisposeCallback', ko.utils.domNodeDisposal.addDisposeCallback);
|
|
ko.exportSymbol('utils.domNodeDisposal.removeDisposeCallback', ko.utils.domNodeDisposal.removeDisposeCallback);
|
|
(function () {
|
|
var leadingCommentRegex = /^(\s*)<!--(.*?)-->/;
|
|
|
|
function simpleHtmlParse(html, documentContext) {
|
|
documentContext || (documentContext = document);
|
|
var windowContext = documentContext['parentWindow'] || documentContext['defaultView'] || window;
|
|
|
|
// Based on jQuery's "clean" function, but only accounting for table-related elements.
|
|
// If you have referenced jQuery, this won't be used anyway - KO will use jQuery's "clean" function directly
|
|
|
|
// Note that there's still an issue in IE < 9 whereby it will discard comment nodes that are the first child of
|
|
// a descendant node. For example: "<div><!-- mycomment -->abc</div>" will get parsed as "<div>abc</div>"
|
|
// This won't affect anyone who has referenced jQuery, and there's always the workaround of inserting a dummy node
|
|
// (possibly a text node) in front of the comment. So, KO does not attempt to workaround this IE issue automatically at present.
|
|
|
|
// Trim whitespace, otherwise indexOf won't work as expected
|
|
var tags = ko.utils.stringTrim(html).toLowerCase(), div = documentContext.createElement("div");
|
|
|
|
// Finds the first match from the left column, and returns the corresponding "wrap" data from the right column
|
|
var wrap = tags.match(/^<(thead|tbody|tfoot)/) && [1, "<table>", "</table>"] ||
|
|
!tags.indexOf("<tr") && [2, "<table><tbody>", "</tbody></table>"] ||
|
|
(!tags.indexOf("<td") || !tags.indexOf("<th")) && [3, "<table><tbody><tr>", "</tr></tbody></table>"] ||
|
|
/* anything else */ [0, "", ""];
|
|
|
|
// Go to html and back, then peel off extra wrappers
|
|
// Note that we always prefix with some dummy text, because otherwise, IE<9 will strip out leading comment nodes in descendants. Total madness.
|
|
var markup = "ignored<div>" + wrap[1] + html + wrap[2] + "</div>";
|
|
if (typeof windowContext['innerShiv'] == "function") {
|
|
div.appendChild(windowContext['innerShiv'](markup));
|
|
} else {
|
|
div.innerHTML = markup;
|
|
}
|
|
|
|
// Move to the right depth
|
|
while (wrap[0]--)
|
|
div = div.lastChild;
|
|
|
|
return ko.utils.makeArray(div.lastChild.childNodes);
|
|
}
|
|
|
|
function jQueryHtmlParse(html, documentContext) {
|
|
// jQuery's "parseHTML" function was introduced in jQuery 1.8.0 and is a documented public API.
|
|
if (jQueryInstance['parseHTML']) {
|
|
return jQueryInstance['parseHTML'](html, documentContext) || []; // Ensure we always return an array and never null
|
|
} else {
|
|
// For jQuery < 1.8.0, we fall back on the undocumented internal "clean" function.
|
|
var elems = jQueryInstance['clean']([html], documentContext);
|
|
|
|
// As of jQuery 1.7.1, jQuery parses the HTML by appending it to some dummy parent nodes held in an in-memory document fragment.
|
|
// Unfortunately, it never clears the dummy parent nodes from the document fragment, so it leaks memory over time.
|
|
// Fix this by finding the top-most dummy parent element, and detaching it from its owner fragment.
|
|
if (elems && elems[0]) {
|
|
// Find the top-most parent element that's a direct child of a document fragment
|
|
var elem = elems[0];
|
|
while (elem.parentNode && elem.parentNode.nodeType !== 11 /* i.e., DocumentFragment */)
|
|
elem = elem.parentNode;
|
|
// ... then detach it
|
|
if (elem.parentNode)
|
|
elem.parentNode.removeChild(elem);
|
|
}
|
|
|
|
return elems;
|
|
}
|
|
}
|
|
|
|
ko.utils.parseHtmlFragment = function(html, documentContext) {
|
|
return jQueryInstance ? jQueryHtmlParse(html, documentContext) // As below, benefit from jQuery's optimisations where possible
|
|
: simpleHtmlParse(html, documentContext); // ... otherwise, this simple logic will do in most common cases.
|
|
};
|
|
|
|
ko.utils.setHtml = function(node, html) {
|
|
ko.utils.emptyDomNode(node);
|
|
|
|
// There's no legitimate reason to display a stringified observable without unwrapping it, so we'll unwrap it
|
|
html = ko.utils.unwrapObservable(html);
|
|
|
|
if ((html !== null) && (html !== undefined)) {
|
|
if (typeof html != 'string')
|
|
html = html.toString();
|
|
|
|
// jQuery contains a lot of sophisticated code to parse arbitrary HTML fragments,
|
|
// for example <tr> elements which are not normally allowed to exist on their own.
|
|
// If you've referenced jQuery we'll use that rather than duplicating its code.
|
|
if (jQueryInstance) {
|
|
jQueryInstance(node)['html'](html);
|
|
} else {
|
|
// ... otherwise, use KO's own parsing logic.
|
|
var parsedNodes = ko.utils.parseHtmlFragment(html, node.ownerDocument);
|
|
for (var i = 0; i < parsedNodes.length; i++)
|
|
node.appendChild(parsedNodes[i]);
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
|
|
ko.exportSymbol('utils.parseHtmlFragment', ko.utils.parseHtmlFragment);
|
|
ko.exportSymbol('utils.setHtml', ko.utils.setHtml);
|
|
|
|
ko.memoization = (function () {
|
|
var memos = {};
|
|
|
|
function randomMax8HexChars() {
|
|
return (((1 + Math.random()) * 0x100000000) | 0).toString(16).substring(1);
|
|
}
|
|
function generateRandomId() {
|
|
return randomMax8HexChars() + randomMax8HexChars();
|
|
}
|
|
function findMemoNodes(rootNode, appendToArray) {
|
|
if (!rootNode)
|
|
return;
|
|
if (rootNode.nodeType == 8) {
|
|
var memoId = ko.memoization.parseMemoText(rootNode.nodeValue);
|
|
if (memoId != null)
|
|
appendToArray.push({ domNode: rootNode, memoId: memoId });
|
|
} else if (rootNode.nodeType == 1) {
|
|
for (var i = 0, childNodes = rootNode.childNodes, j = childNodes.length; i < j; i++)
|
|
findMemoNodes(childNodes[i], appendToArray);
|
|
}
|
|
}
|
|
|
|
return {
|
|
memoize: function (callback) {
|
|
if (typeof callback != "function")
|
|
throw new Error("You can only pass a function to ko.memoization.memoize()");
|
|
var memoId = generateRandomId();
|
|
memos[memoId] = callback;
|
|
return "<!--[ko_memo:" + memoId + "]-->";
|
|
},
|
|
|
|
unmemoize: function (memoId, callbackParams) {
|
|
var callback = memos[memoId];
|
|
if (callback === undefined)
|
|
throw new Error("Couldn't find any memo with ID " + memoId + ". Perhaps it's already been unmemoized.");
|
|
try {
|
|
callback.apply(null, callbackParams || []);
|
|
return true;
|
|
}
|
|
finally { delete memos[memoId]; }
|
|
},
|
|
|
|
unmemoizeDomNodeAndDescendants: function (domNode, extraCallbackParamsArray) {
|
|
var memos = [];
|
|
findMemoNodes(domNode, memos);
|
|
for (var i = 0, j = memos.length; i < j; i++) {
|
|
var node = memos[i].domNode;
|
|
var combinedParams = [node];
|
|
if (extraCallbackParamsArray)
|
|
ko.utils.arrayPushAll(combinedParams, extraCallbackParamsArray);
|
|
ko.memoization.unmemoize(memos[i].memoId, combinedParams);
|
|
node.nodeValue = ""; // Neuter this node so we don't try to unmemoize it again
|
|
if (node.parentNode)
|
|
node.parentNode.removeChild(node); // If possible, erase it totally (not always possible - someone else might just hold a reference to it then call unmemoizeDomNodeAndDescendants again)
|
|
}
|
|
},
|
|
|
|
parseMemoText: function (memoText) {
|
|
var match = memoText.match(/^\[ko_memo\:(.*?)\]$/);
|
|
return match ? match[1] : null;
|
|
}
|
|
};
|
|
})();
|
|
|
|
ko.exportSymbol('memoization', ko.memoization);
|
|
ko.exportSymbol('memoization.memoize', ko.memoization.memoize);
|
|
ko.exportSymbol('memoization.unmemoize', ko.memoization.unmemoize);
|
|
ko.exportSymbol('memoization.parseMemoText', ko.memoization.parseMemoText);
|
|
ko.exportSymbol('memoization.unmemoizeDomNodeAndDescendants', ko.memoization.unmemoizeDomNodeAndDescendants);
|
|
ko.extenders = {
|
|
'throttle': function(target, timeout) {
|
|
// Throttling means two things:
|
|
|
|
// (1) For dependent observables, we throttle *evaluations* so that, no matter how fast its dependencies
|
|
// notify updates, the target doesn't re-evaluate (and hence doesn't notify) faster than a certain rate
|
|
target['throttleEvaluation'] = timeout;
|
|
|
|
// (2) For writable targets (observables, or writable dependent observables), we throttle *writes*
|
|
// so the target cannot change value synchronously or faster than a certain rate
|
|
var writeTimeoutInstance = null;
|
|
return ko.dependentObservable({
|
|
'read': target,
|
|
'write': function(value) {
|
|
clearTimeout(writeTimeoutInstance);
|
|
writeTimeoutInstance = setTimeout(function() {
|
|
target(value);
|
|
}, timeout);
|
|
}
|
|
});
|
|
},
|
|
|
|
'rateLimit': function(target, options) {
|
|
var timeout, method, limitFunction;
|
|
|
|
if (typeof options == 'number') {
|
|
timeout = options;
|
|
} else {
|
|
timeout = options['timeout'];
|
|
method = options['method'];
|
|
}
|
|
|
|
limitFunction = method == 'notifyWhenChangesStop' ? debounce : throttle;
|
|
target.limit(function(callback) {
|
|
return limitFunction(callback, timeout);
|
|
});
|
|
},
|
|
|
|
'notify': function(target, notifyWhen) {
|
|
target["equalityComparer"] = notifyWhen == "always" ?
|
|
null : // null equalityComparer means to always notify
|
|
valuesArePrimitiveAndEqual;
|
|
}
|
|
};
|
|
|
|
var primitiveTypes = { 'undefined':1, 'boolean':1, 'number':1, 'string':1 };
|
|
function valuesArePrimitiveAndEqual(a, b) {
|
|
var oldValueIsPrimitive = (a === null) || (typeof(a) in primitiveTypes);
|
|
return oldValueIsPrimitive ? (a === b) : false;
|
|
}
|
|
|
|
function throttle(callback, timeout) {
|
|
var timeoutInstance;
|
|
return function () {
|
|
if (!timeoutInstance) {
|
|
timeoutInstance = setTimeout(function() {
|
|
timeoutInstance = undefined;
|
|
callback();
|
|
}, timeout);
|
|
}
|
|
};
|
|
}
|
|
|
|
function debounce(callback, timeout) {
|
|
var timeoutInstance;
|
|
return function () {
|
|
clearTimeout(timeoutInstance);
|
|
timeoutInstance = setTimeout(callback, timeout);
|
|
};
|
|
}
|
|
|
|
function applyExtenders(requestedExtenders) {
|
|
var target = this;
|
|
if (requestedExtenders) {
|
|
ko.utils.objectForEach(requestedExtenders, function(key, value) {
|
|
var extenderHandler = ko.extenders[key];
|
|
if (typeof extenderHandler == 'function') {
|
|
target = extenderHandler(target, value) || target;
|
|
}
|
|
});
|
|
}
|
|
return target;
|
|
}
|
|
|
|
ko.exportSymbol('extenders', ko.extenders);
|
|
|
|
ko.subscription = function (target, callback, disposeCallback) {
|
|
this._target = target;
|
|
this.callback = callback;
|
|
this.disposeCallback = disposeCallback;
|
|
this.isDisposed = false;
|
|
ko.exportProperty(this, 'dispose', this.dispose);
|
|
};
|
|
ko.subscription.prototype.dispose = function () {
|
|
this.isDisposed = true;
|
|
this.disposeCallback();
|
|
};
|
|
|
|
ko.subscribable = function () {
|
|
ko.utils.setPrototypeOfOrExtend(this, ko.subscribable['fn']);
|
|
this._subscriptions = {};
|
|
this._versionNumber = 1;
|
|
}
|
|
|
|
var defaultEvent = "change";
|
|
|
|
var ko_subscribable_fn = {
|
|
subscribe: function (callback, callbackTarget, event) {
|
|
var self = this;
|
|
|
|
event = event || defaultEvent;
|
|
var boundCallback = callbackTarget ? callback.bind(callbackTarget) : callback;
|
|
|
|
var subscription = new ko.subscription(self, boundCallback, function () {
|
|
ko.utils.arrayRemoveItem(self._subscriptions[event], subscription);
|
|
if (self.afterSubscriptionRemove)
|
|
self.afterSubscriptionRemove(event);
|
|
});
|
|
|
|
if (self.beforeSubscriptionAdd)
|
|
self.beforeSubscriptionAdd(event);
|
|
|
|
if (!self._subscriptions[event])
|
|
self._subscriptions[event] = [];
|
|
self._subscriptions[event].push(subscription);
|
|
|
|
return subscription;
|
|
},
|
|
|
|
"notifySubscribers": function (valueToNotify, event) {
|
|
event = event || defaultEvent;
|
|
if (event === defaultEvent) {
|
|
this.updateVersion();
|
|
}
|
|
if (this.hasSubscriptionsForEvent(event)) {
|
|
try {
|
|
ko.dependencyDetection.begin(); // Begin suppressing dependency detection (by setting the top frame to undefined)
|
|
for (var a = this._subscriptions[event].slice(0), i = 0, subscription; subscription = a[i]; ++i) {
|
|
// In case a subscription was disposed during the arrayForEach cycle, check
|
|
// for isDisposed on each subscription before invoking its callback
|
|
if (!subscription.isDisposed)
|
|
subscription.callback(valueToNotify);
|
|
}
|
|
} finally {
|
|
ko.dependencyDetection.end(); // End suppressing dependency detection
|
|
}
|
|
}
|
|
},
|
|
|
|
getVersion: function () {
|
|
return this._versionNumber;
|
|
},
|
|
|
|
hasChanged: function (versionToCheck) {
|
|
return this.getVersion() !== versionToCheck;
|
|
},
|
|
|
|
updateVersion: function () {
|
|
++this._versionNumber;
|
|
},
|
|
|
|
limit: function(limitFunction) {
|
|
var self = this, selfIsObservable = ko.isObservable(self),
|
|
isPending, previousValue, pendingValue, beforeChange = 'beforeChange';
|
|
|
|
if (!self._origNotifySubscribers) {
|
|
self._origNotifySubscribers = self["notifySubscribers"];
|
|
self["notifySubscribers"] = function(value, event) {
|
|
if (!event || event === defaultEvent) {
|
|
self._rateLimitedChange(value);
|
|
} else if (event === beforeChange) {
|
|
self._rateLimitedBeforeChange(value);
|
|
} else {
|
|
self._origNotifySubscribers(value, event);
|
|
}
|
|
};
|
|
}
|
|
|
|
var finish = limitFunction(function() {
|
|
// If an observable provided a reference to itself, access it to get the latest value.
|
|
// This allows computed observables to delay calculating their value until needed.
|
|
if (selfIsObservable && pendingValue === self) {
|
|
pendingValue = self();
|
|
}
|
|
isPending = false;
|
|
if (self.isDifferent(previousValue, pendingValue)) {
|
|
self._origNotifySubscribers(previousValue = pendingValue);
|
|
}
|
|
});
|
|
|
|
self._rateLimitedChange = function(value) {
|
|
isPending = true;
|
|
pendingValue = value;
|
|
finish();
|
|
};
|
|
self._rateLimitedBeforeChange = function(value) {
|
|
if (!isPending) {
|
|
previousValue = value;
|
|
self._origNotifySubscribers(value, beforeChange);
|
|
}
|
|
};
|
|
},
|
|
|
|
hasSubscriptionsForEvent: function(event) {
|
|
return this._subscriptions[event] && this._subscriptions[event].length;
|
|
},
|
|
|
|
getSubscriptionsCount: function (event) {
|
|
if (event) {
|
|
return this._subscriptions[event] && this._subscriptions[event].length || 0;
|
|
} else {
|
|
var total = 0;
|
|
ko.utils.objectForEach(this._subscriptions, function(eventName, subscriptions) {
|
|
total += subscriptions.length;
|
|
});
|
|
return total;
|
|
}
|
|
},
|
|
|
|
isDifferent: function(oldValue, newValue) {
|
|
return !this['equalityComparer'] || !this['equalityComparer'](oldValue, newValue);
|
|
},
|
|
|
|
extend: applyExtenders
|
|
};
|
|
|
|
ko.exportProperty(ko_subscribable_fn, 'subscribe', ko_subscribable_fn.subscribe);
|
|
ko.exportProperty(ko_subscribable_fn, 'extend', ko_subscribable_fn.extend);
|
|
ko.exportProperty(ko_subscribable_fn, 'getSubscriptionsCount', ko_subscribable_fn.getSubscriptionsCount);
|
|
|
|
// For browsers that support proto assignment, we overwrite the prototype of each
|
|
// observable instance. Since observables are functions, we need Function.prototype
|
|
// to still be in the prototype chain.
|
|
if (ko.utils.canSetPrototype) {
|
|
ko.utils.setPrototypeOf(ko_subscribable_fn, Function.prototype);
|
|
}
|
|
|
|
ko.subscribable['fn'] = ko_subscribable_fn;
|
|
|
|
|
|
ko.isSubscribable = function (instance) {
|
|
return instance != null && typeof instance.subscribe == "function" && typeof instance["notifySubscribers"] == "function";
|
|
};
|
|
|
|
ko.exportSymbol('subscribable', ko.subscribable);
|
|
ko.exportSymbol('isSubscribable', ko.isSubscribable);
|
|
|
|
ko.computedContext = ko.dependencyDetection = (function () {
|
|
var outerFrames = [],
|
|
currentFrame,
|
|
lastId = 0;
|
|
|
|
// Return a unique ID that can be assigned to an observable for dependency tracking.
|
|
// Theoretically, you could eventually overflow the number storage size, resulting
|
|
// in duplicate IDs. But in JavaScript, the largest exact integral value is 2^53
|
|
// or 9,007,199,254,740,992. If you created 1,000,000 IDs per second, it would
|
|
// take over 285 years to reach that number.
|
|
// Reference http://blog.vjeux.com/2010/javascript/javascript-max_int-number-limits.html
|
|
function getId() {
|
|
return ++lastId;
|
|
}
|
|
|
|
function begin(options) {
|
|
outerFrames.push(currentFrame);
|
|
currentFrame = options;
|
|
}
|
|
|
|
function end() {
|
|
currentFrame = outerFrames.pop();
|
|
}
|
|
|
|
return {
|
|
begin: begin,
|
|
|
|
end: end,
|
|
|
|
registerDependency: function (subscribable) {
|
|
if (currentFrame) {
|
|
if (!ko.isSubscribable(subscribable))
|
|
throw new Error("Only subscribable things can act as dependencies");
|
|
currentFrame.callback(subscribable, subscribable._id || (subscribable._id = getId()));
|
|
}
|
|
},
|
|
|
|
ignore: function (callback, callbackTarget, callbackArgs) {
|
|
try {
|
|
begin();
|
|
return callback.apply(callbackTarget, callbackArgs || []);
|
|
} finally {
|
|
end();
|
|
}
|
|
},
|
|
|
|
getDependenciesCount: function () {
|
|
if (currentFrame)
|
|
return currentFrame.computed.getDependenciesCount();
|
|
},
|
|
|
|
isInitial: function() {
|
|
if (currentFrame)
|
|
return currentFrame.isInitial;
|
|
}
|
|
};
|
|
})();
|
|
|
|
ko.exportSymbol('computedContext', ko.computedContext);
|
|
ko.exportSymbol('computedContext.getDependenciesCount', ko.computedContext.getDependenciesCount);
|
|
ko.exportSymbol('computedContext.isInitial', ko.computedContext.isInitial);
|
|
ko.exportSymbol('computedContext.isSleeping', ko.computedContext.isSleeping);
|
|
|
|
ko.exportSymbol('ignoreDependencies', ko.ignoreDependencies = ko.dependencyDetection.ignore);
|
|
ko.observable = function (initialValue) {
|
|
var _latestValue = initialValue;
|
|
|
|
function observable() {
|
|
if (arguments.length > 0) {
|
|
// Write
|
|
|
|
// Ignore writes if the value hasn't changed
|
|
if (observable.isDifferent(_latestValue, arguments[0])) {
|
|
observable.valueWillMutate();
|
|
_latestValue = arguments[0];
|
|
if (DEBUG) observable._latestValue = _latestValue;
|
|
observable.valueHasMutated();
|
|
}
|
|
return this; // Permits chained assignments
|
|
}
|
|
else {
|
|
// Read
|
|
ko.dependencyDetection.registerDependency(observable); // The caller only needs to be notified of changes if they did a "read" operation
|
|
return _latestValue;
|
|
}
|
|
}
|
|
ko.subscribable.call(observable);
|
|
ko.utils.setPrototypeOfOrExtend(observable, ko.observable['fn']);
|
|
|
|
if (DEBUG) observable._latestValue = _latestValue;
|
|
observable.peek = function() { return _latestValue };
|
|
observable.valueHasMutated = function () { observable["notifySubscribers"](_latestValue); }
|
|
observable.valueWillMutate = function () { observable["notifySubscribers"](_latestValue, "beforeChange"); }
|
|
|
|
ko.exportProperty(observable, 'peek', observable.peek);
|
|
ko.exportProperty(observable, "valueHasMutated", observable.valueHasMutated);
|
|
ko.exportProperty(observable, "valueWillMutate", observable.valueWillMutate);
|
|
|
|
return observable;
|
|
}
|
|
|
|
ko.observable['fn'] = {
|
|
"equalityComparer": valuesArePrimitiveAndEqual
|
|
};
|
|
|
|
var protoProperty = ko.observable.protoProperty = "__ko_proto__";
|
|
ko.observable['fn'][protoProperty] = ko.observable;
|
|
|
|
// Note that for browsers that don't support proto assignment, the
|
|
// inheritance chain is created manually in the ko.observable constructor
|
|
if (ko.utils.canSetPrototype) {
|
|
ko.utils.setPrototypeOf(ko.observable['fn'], ko.subscribable['fn']);
|
|
}
|
|
|
|
ko.hasPrototype = function(instance, prototype) {
|
|
if ((instance === null) || (instance === undefined) || (instance[protoProperty] === undefined)) return false;
|
|
if (instance[protoProperty] === prototype) return true;
|
|
return ko.hasPrototype(instance[protoProperty], prototype); // Walk the prototype chain
|
|
};
|
|
|
|
ko.isObservable = function (instance) {
|
|
return ko.hasPrototype(instance, ko.observable);
|
|
}
|
|
ko.isWriteableObservable = function (instance) {
|
|
// Observable
|
|
if ((typeof instance == "function") && instance[protoProperty] === ko.observable)
|
|
return true;
|
|
// Writeable dependent observable
|
|
if ((typeof instance == "function") && (instance[protoProperty] === ko.dependentObservable) && (instance.hasWriteFunction))
|
|
return true;
|
|
// Anything else
|
|
return false;
|
|
}
|
|
|
|
|
|
ko.exportSymbol('observable', ko.observable);
|
|
ko.exportSymbol('isObservable', ko.isObservable);
|
|
ko.exportSymbol('isWriteableObservable', ko.isWriteableObservable);
|
|
ko.exportSymbol('isWritableObservable', ko.isWriteableObservable);
|
|
ko.observableArray = function (initialValues) {
|
|
initialValues = initialValues || [];
|
|
|
|
if (typeof initialValues != 'object' || !('length' in initialValues))
|
|
throw new Error("The argument passed when initializing an observable array must be an array, or null, or undefined.");
|
|
|
|
var result = ko.observable(initialValues);
|
|
ko.utils.setPrototypeOfOrExtend(result, ko.observableArray['fn']);
|
|
return result.extend({'trackArrayChanges':true});
|
|
};
|
|
|
|
ko.observableArray['fn'] = {
|
|
'remove': function (valueOrPredicate) {
|
|
var underlyingArray = this.peek();
|
|
var removedValues = [];
|
|
var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
|
|
for (var i = 0; i < underlyingArray.length; i++) {
|
|
var value = underlyingArray[i];
|
|
if (predicate(value)) {
|
|
if (removedValues.length === 0) {
|
|
this.valueWillMutate();
|
|
}
|
|
removedValues.push(value);
|
|
underlyingArray.splice(i, 1);
|
|
i--;
|
|
}
|
|
}
|
|
if (removedValues.length) {
|
|
this.valueHasMutated();
|
|
}
|
|
return removedValues;
|
|
},
|
|
|
|
'removeAll': function (arrayOfValues) {
|
|
// If you passed zero args, we remove everything
|
|
if (arrayOfValues === undefined) {
|
|
var underlyingArray = this.peek();
|
|
var allValues = underlyingArray.slice(0);
|
|
this.valueWillMutate();
|
|
underlyingArray.splice(0, underlyingArray.length);
|
|
this.valueHasMutated();
|
|
return allValues;
|
|
}
|
|
// If you passed an arg, we interpret it as an array of entries to remove
|
|
if (!arrayOfValues)
|
|
return [];
|
|
return this['remove'](function (value) {
|
|
return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;
|
|
});
|
|
},
|
|
|
|
'destroy': function (valueOrPredicate) {
|
|
var underlyingArray = this.peek();
|
|
var predicate = typeof valueOrPredicate == "function" && !ko.isObservable(valueOrPredicate) ? valueOrPredicate : function (value) { return value === valueOrPredicate; };
|
|
this.valueWillMutate();
|
|
for (var i = underlyingArray.length - 1; i >= 0; i--) {
|
|
var value = underlyingArray[i];
|
|
if (predicate(value))
|
|
underlyingArray[i]["_destroy"] = true;
|
|
}
|
|
this.valueHasMutated();
|
|
},
|
|
|
|
'destroyAll': function (arrayOfValues) {
|
|
// If you passed zero args, we destroy everything
|
|
if (arrayOfValues === undefined)
|
|
return this['destroy'](function() { return true });
|
|
|
|
// If you passed an arg, we interpret it as an array of entries to destroy
|
|
if (!arrayOfValues)
|
|
return [];
|
|
return this['destroy'](function (value) {
|
|
return ko.utils.arrayIndexOf(arrayOfValues, value) >= 0;
|
|
});
|
|
},
|
|
|
|
'indexOf': function (item) {
|
|
var underlyingArray = this();
|
|
return ko.utils.arrayIndexOf(underlyingArray, item);
|
|
},
|
|
|
|
'replace': function(oldItem, newItem) {
|
|
var index = this['indexOf'](oldItem);
|
|
if (index >= 0) {
|
|
this.valueWillMutate();
|
|
this.peek()[index] = newItem;
|
|
this.valueHasMutated();
|
|
}
|
|
}
|
|
};
|
|
|
|
// Populate ko.observableArray.fn with read/write functions from native arrays
|
|
// Important: Do not add any additional functions here that may reasonably be used to *read* data from the array
|
|
// because we'll eval them without causing subscriptions, so ko.computed output could end up getting stale
|
|
ko.utils.arrayForEach(["pop", "push", "reverse", "shift", "sort", "splice", "unshift"], function (methodName) {
|
|
ko.observableArray['fn'][methodName] = function () {
|
|
// Use "peek" to avoid creating a subscription in any computed that we're executing in the context of
|
|
// (for consistency with mutating regular observables)
|
|
var underlyingArray = this.peek();
|
|
this.valueWillMutate();
|
|
this.cacheDiffForKnownOperation(underlyingArray, methodName, arguments);
|
|
var methodCallResult = underlyingArray[methodName].apply(underlyingArray, arguments);
|
|
this.valueHasMutated();
|
|
return methodCallResult;
|
|
};
|
|
});
|
|
|
|
// Populate ko.observableArray.fn with read-only functions from native arrays
|
|
ko.utils.arrayForEach(["slice"], function (methodName) {
|
|
ko.observableArray['fn'][methodName] = function () {
|
|
var underlyingArray = this();
|
|
return underlyingArray[methodName].apply(underlyingArray, arguments);
|
|
};
|
|
});
|
|
|
|
// Note that for browsers that don't support proto assignment, the
|
|
// inheritance chain is created manually in the ko.observableArray constructor
|
|
if (ko.utils.canSetPrototype) {
|
|
ko.utils.setPrototypeOf(ko.observableArray['fn'], ko.observable['fn']);
|
|
}
|
|
|
|
ko.exportSymbol('observableArray', ko.observableArray);
|
|
var arrayChangeEventName = 'arrayChange';
|
|
ko.extenders['trackArrayChanges'] = function(target) {
|
|
// Only modify the target observable once
|
|
if (target.cacheDiffForKnownOperation) {
|
|
return;
|
|
}
|
|
var trackingChanges = false,
|
|
cachedDiff = null,
|
|
arrayChangeSubscription,
|
|
pendingNotifications = 0,
|
|
underlyingBeforeSubscriptionAddFunction = target.beforeSubscriptionAdd,
|
|
underlyingAfterSubscriptionRemoveFunction = target.afterSubscriptionRemove;
|
|
|
|
// Watch "subscribe" calls, and for array change events, ensure change tracking is enabled
|
|
target.beforeSubscriptionAdd = function (event) {
|
|
if (underlyingBeforeSubscriptionAddFunction)
|
|
underlyingBeforeSubscriptionAddFunction.call(target, event);
|
|
if (event === arrayChangeEventName) {
|
|
trackChanges();
|
|
}
|
|
};
|
|
// Watch "dispose" calls, and for array change events, ensure change tracking is disabled when all are disposed
|
|
target.afterSubscriptionRemove = function (event) {
|
|
if (underlyingAfterSubscriptionRemoveFunction)
|
|
underlyingAfterSubscriptionRemoveFunction.call(target, event);
|
|
if (event === arrayChangeEventName && !target.hasSubscriptionsForEvent(arrayChangeEventName)) {
|
|
arrayChangeSubscription.dispose();
|
|
trackingChanges = false;
|
|
}
|
|
};
|
|
|
|
function trackChanges() {
|
|
// Calling 'trackChanges' multiple times is the same as calling it once
|
|
if (trackingChanges) {
|
|
return;
|
|
}
|
|
|
|
trackingChanges = true;
|
|
|
|
// Intercept "notifySubscribers" to track how many times it was called.
|
|
var underlyingNotifySubscribersFunction = target['notifySubscribers'];
|
|
target['notifySubscribers'] = function(valueToNotify, event) {
|
|
if (!event || event === defaultEvent) {
|
|
++pendingNotifications;
|
|
}
|
|
return underlyingNotifySubscribersFunction.apply(this, arguments);
|
|
};
|
|
|
|
// Each time the array changes value, capture a clone so that on the next
|
|
// change it's possible to produce a diff
|
|
var previousContents = [].concat(target.peek() || []);
|
|
cachedDiff = null;
|
|
arrayChangeSubscription = target.subscribe(function(currentContents) {
|
|
// Make a copy of the current contents and ensure it's an array
|
|
currentContents = [].concat(currentContents || []);
|
|
|
|
// Compute the diff and issue notifications, but only if someone is listening
|
|
if (target.hasSubscriptionsForEvent(arrayChangeEventName)) {
|
|
var changes = getChanges(previousContents, currentContents);
|
|
}
|
|
|
|
// Eliminate references to the old, removed items, so they can be GCed
|
|
previousContents = currentContents;
|
|
cachedDiff = null;
|
|
pendingNotifications = 0;
|
|
|
|
if (changes && changes.length) {
|
|
target['notifySubscribers'](changes, arrayChangeEventName);
|
|
}
|
|
});
|
|
}
|
|
|
|
function getChanges(previousContents, currentContents) {
|
|
// We try to re-use cached diffs.
|
|
// The scenarios where pendingNotifications > 1 are when using rate-limiting or the Deferred Updates
|
|
// plugin, which without this check would not be compatible with arrayChange notifications. Normally,
|
|
// notifications are issued immediately so we wouldn't be queueing up more than one.
|
|
if (!cachedDiff || pendingNotifications > 1) {
|
|
cachedDiff = ko.utils.compareArrays(previousContents, currentContents, { 'sparse': true });
|
|
}
|
|
|
|
return cachedDiff;
|
|
}
|
|
|
|
target.cacheDiffForKnownOperation = function(rawArray, operationName, args) {
|
|
// Only run if we're currently tracking changes for this observable array
|
|
// and there aren't any pending deferred notifications.
|
|
if (!trackingChanges || pendingNotifications) {
|
|
return;
|
|
}
|
|
var diff = [],
|
|
arrayLength = rawArray.length,
|
|
argsLength = args.length,
|
|
offset = 0;
|
|
|
|
function pushDiff(status, value, index) {
|
|
return diff[diff.length] = { 'status': status, 'value': value, 'index': index };
|
|
}
|
|
switch (operationName) {
|
|
case 'push':
|
|
offset = arrayLength;
|
|
case 'unshift':
|
|
for (var index = 0; index < argsLength; index++) {
|
|
pushDiff('added', args[index], offset + index);
|
|
}
|
|
break;
|
|
|
|
case 'pop':
|
|
offset = arrayLength - 1;
|
|
case 'shift':
|
|
if (arrayLength) {
|
|
pushDiff('deleted', rawArray[offset], offset);
|
|
}
|
|
break;
|
|
|
|
case 'splice':
|
|
// Negative start index means 'from end of array'. After that we clamp to [0...arrayLength].
|
|
// See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/splice
|
|
var startIndex = Math.min(Math.max(0, args[0] < 0 ? arrayLength + args[0] : args[0]), arrayLength),
|
|
endDeleteIndex = argsLength === 1 ? arrayLength : Math.min(startIndex + (args[1] || 0), arrayLength),
|
|
endAddIndex = startIndex + argsLength - 2,
|
|
endIndex = Math.max(endDeleteIndex, endAddIndex),
|
|
additions = [], deletions = [];
|
|
for (var index = startIndex, argsIndex = 2; index < endIndex; ++index, ++argsIndex) {
|
|
if (index < endDeleteIndex)
|
|
deletions.push(pushDiff('deleted', rawArray[index], index));
|
|
if (index < endAddIndex)
|
|
additions.push(pushDiff('added', args[argsIndex], index));
|
|
}
|
|
ko.utils.findMovesInArrayComparison(deletions, additions);
|
|
break;
|
|
|
|
default:
|
|
return;
|
|
}
|
|
cachedDiff = diff;
|
|
};
|
|
};
|
|
ko.computed = ko.dependentObservable = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget, options) {
|
|
var _latestValue,
|
|
_needsEvaluation = true,
|
|
_isBeingEvaluated = false,
|
|
_suppressDisposalUntilDisposeWhenReturnsFalse = false,
|
|
_isDisposed = false,
|
|
readFunction = evaluatorFunctionOrOptions,
|
|
pure = false,
|
|
isSleeping = false;
|
|
|
|
if (readFunction && typeof readFunction == "object") {
|
|
// Single-parameter syntax - everything is on this "options" param
|
|
options = readFunction;
|
|
readFunction = options["read"];
|
|
} else {
|
|
// Multi-parameter syntax - construct the options according to the params passed
|
|
options = options || {};
|
|
if (!readFunction)
|
|
readFunction = options["read"];
|
|
}
|
|
if (typeof readFunction != "function")
|
|
throw new Error("Pass a function that returns the value of the ko.computed");
|
|
|
|
function addDependencyTracking(id, target, trackingObj) {
|
|
if (pure && target === dependentObservable) {
|
|
throw Error("A 'pure' computed must not be called recursively");
|
|
}
|
|
|
|
dependencyTracking[id] = trackingObj;
|
|
trackingObj._order = _dependenciesCount++;
|
|
trackingObj._version = target.getVersion();
|
|
}
|
|
|
|
function haveDependenciesChanged() {
|
|
var id, dependency;
|
|
for (id in dependencyTracking) {
|
|
if (dependencyTracking.hasOwnProperty(id)) {
|
|
dependency = dependencyTracking[id];
|
|
if (dependency._target.hasChanged(dependency._version)) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function disposeComputed() {
|
|
if (!isSleeping && dependencyTracking) {
|
|
ko.utils.objectForEach(dependencyTracking, function (id, dependency) {
|
|
if (dependency.dispose)
|
|
dependency.dispose();
|
|
});
|
|
}
|
|
dependencyTracking = null;
|
|
_dependenciesCount = 0;
|
|
_isDisposed = true;
|
|
_needsEvaluation = false;
|
|
isSleeping = false;
|
|
}
|
|
|
|
function evaluatePossiblyAsync() {
|
|
var throttleEvaluationTimeout = dependentObservable['throttleEvaluation'];
|
|
if (throttleEvaluationTimeout && throttleEvaluationTimeout >= 0) {
|
|
clearTimeout(evaluationTimeoutInstance);
|
|
evaluationTimeoutInstance = setTimeout(function () {
|
|
evaluateImmediate(true /*notifyChange*/);
|
|
}, throttleEvaluationTimeout);
|
|
} else if (dependentObservable._evalRateLimited) {
|
|
dependentObservable._evalRateLimited();
|
|
} else {
|
|
evaluateImmediate(true /*notifyChange*/);
|
|
}
|
|
}
|
|
|
|
function evaluateImmediate(notifyChange) {
|
|
if (_isBeingEvaluated) {
|
|
// If the evaluation of a ko.computed causes side effects, it's possible that it will trigger its own re-evaluation.
|
|
// This is not desirable (it's hard for a developer to realise a chain of dependencies might cause this, and they almost
|
|
// certainly didn't intend infinite re-evaluations). So, for predictability, we simply prevent ko.computeds from causing
|
|
// their own re-evaluation. Further discussion at https://github.com/SteveSanderson/knockout/pull/387
|
|
return;
|
|
}
|
|
|
|
// Do not evaluate (and possibly capture new dependencies) if disposed
|
|
if (_isDisposed) {
|
|
return;
|
|
}
|
|
|
|
if (disposeWhen && disposeWhen()) {
|
|
// See comment below about _suppressDisposalUntilDisposeWhenReturnsFalse
|
|
if (!_suppressDisposalUntilDisposeWhenReturnsFalse) {
|
|
dispose();
|
|
return;
|
|
}
|
|
} else {
|
|
// It just did return false, so we can stop suppressing now
|
|
_suppressDisposalUntilDisposeWhenReturnsFalse = false;
|
|
}
|
|
|
|
_isBeingEvaluated = true;
|
|
|
|
try {
|
|
// Initially, we assume that none of the subscriptions are still being used (i.e., all are candidates for disposal).
|
|
// Then, during evaluation, we cross off any that are in fact still being used.
|
|
var disposalCandidates = dependencyTracking,
|
|
disposalCount = _dependenciesCount,
|
|
isInitial = pure ? undefined : !_dependenciesCount; // If we're evaluating when there are no previous dependencies, it must be the first time
|
|
|
|
ko.dependencyDetection.begin({
|
|
callback: function(subscribable, id) {
|
|
if (!_isDisposed) {
|
|
if (disposalCount && disposalCandidates[id]) {
|
|
// Don't want to dispose this subscription, as it's still being used
|
|
addDependencyTracking(id, subscribable, disposalCandidates[id]);
|
|
delete disposalCandidates[id];
|
|
--disposalCount;
|
|
} else if (!dependencyTracking[id]) {
|
|
// Brand new subscription - add it
|
|
addDependencyTracking(id, subscribable, isSleeping ? { _target: subscribable } : subscribable.subscribe(evaluatePossiblyAsync));
|
|
}
|
|
}
|
|
},
|
|
computed: dependentObservable,
|
|
isInitial: isInitial
|
|
});
|
|
|
|
dependencyTracking = {};
|
|
_dependenciesCount = 0;
|
|
|
|
try {
|
|
var newValue = evaluatorFunctionTarget ? readFunction.call(evaluatorFunctionTarget) : readFunction();
|
|
|
|
} finally {
|
|
ko.dependencyDetection.end();
|
|
|
|
// For each subscription no longer being used, remove it from the active subscriptions list and dispose it
|
|
if (disposalCount && !isSleeping) {
|
|
ko.utils.objectForEach(disposalCandidates, function(id, toDispose) {
|
|
if (toDispose.dispose)
|
|
toDispose.dispose();
|
|
});
|
|
}
|
|
|
|
_needsEvaluation = false;
|
|
}
|
|
|
|
if (dependentObservable.isDifferent(_latestValue, newValue)) {
|
|
if (!isSleeping) {
|
|
notify(_latestValue, "beforeChange");
|
|
}
|
|
|
|
_latestValue = newValue;
|
|
if (DEBUG) dependentObservable._latestValue = _latestValue;
|
|
|
|
if (isSleeping) {
|
|
dependentObservable.updateVersion();
|
|
} else if (notifyChange) {
|
|
notify(_latestValue);
|
|
}
|
|
}
|
|
|
|
if (isInitial) {
|
|
notify(_latestValue, "awake");
|
|
}
|
|
} finally {
|
|
_isBeingEvaluated = false;
|
|
}
|
|
|
|
if (!_dependenciesCount)
|
|
dispose();
|
|
}
|
|
|
|
function dependentObservable() {
|
|
if (arguments.length > 0) {
|
|
if (typeof writeFunction === "function") {
|
|
// Writing a value
|
|
writeFunction.apply(evaluatorFunctionTarget, arguments);
|
|
} else {
|
|
throw new Error("Cannot write a value to a ko.computed unless you specify a 'write' option. If you wish to read the current value, don't pass any parameters.");
|
|
}
|
|
return this; // Permits chained assignments
|
|
} else {
|
|
// Reading the value
|
|
ko.dependencyDetection.registerDependency(dependentObservable);
|
|
if (_needsEvaluation || (isSleeping && haveDependenciesChanged())) {
|
|
evaluateImmediate();
|
|
}
|
|
return _latestValue;
|
|
}
|
|
}
|
|
|
|
function peek() {
|
|
// Peek won't re-evaluate, except while the computed is sleeping or to get the initial value when "deferEvaluation" is set.
|
|
if ((_needsEvaluation && !_dependenciesCount) || (isSleeping && haveDependenciesChanged())) {
|
|
evaluateImmediate();
|
|
}
|
|
return _latestValue;
|
|
}
|
|
|
|
function isActive() {
|
|
return _needsEvaluation || _dependenciesCount > 0;
|
|
}
|
|
|
|
function notify(value, event) {
|
|
dependentObservable["notifySubscribers"](value, event);
|
|
}
|
|
|
|
// By here, "options" is always non-null
|
|
var writeFunction = options["write"],
|
|
disposeWhenNodeIsRemoved = options["disposeWhenNodeIsRemoved"] || options.disposeWhenNodeIsRemoved || null,
|
|
disposeWhenOption = options["disposeWhen"] || options.disposeWhen,
|
|
disposeWhen = disposeWhenOption,
|
|
dispose = disposeComputed,
|
|
dependencyTracking = {},
|
|
_dependenciesCount = 0,
|
|
evaluationTimeoutInstance = null;
|
|
|
|
if (!evaluatorFunctionTarget)
|
|
evaluatorFunctionTarget = options["owner"];
|
|
|
|
ko.subscribable.call(dependentObservable);
|
|
ko.utils.setPrototypeOfOrExtend(dependentObservable, ko.dependentObservable['fn']);
|
|
|
|
dependentObservable.peek = peek;
|
|
dependentObservable.getDependenciesCount = function () { return _dependenciesCount; };
|
|
dependentObservable.hasWriteFunction = typeof writeFunction === "function";
|
|
dependentObservable.dispose = function () { dispose(); };
|
|
dependentObservable.isActive = isActive;
|
|
|
|
// Replace the limit function with one that delays evaluation as well.
|
|
var originalLimit = dependentObservable.limit;
|
|
dependentObservable.limit = function(limitFunction) {
|
|
originalLimit.call(dependentObservable, limitFunction);
|
|
dependentObservable._evalRateLimited = function() {
|
|
dependentObservable._rateLimitedBeforeChange(_latestValue);
|
|
|
|
_needsEvaluation = true; // Mark as dirty
|
|
|
|
// Pass the observable to the rate-limit code, which will access it when
|
|
// it's time to do the notification.
|
|
dependentObservable._rateLimitedChange(dependentObservable);
|
|
}
|
|
};
|
|
|
|
if (options['pure']) {
|
|
pure = true;
|
|
isSleeping = true; // Starts off sleeping; will awake on the first subscription
|
|
dependentObservable.beforeSubscriptionAdd = function (event) {
|
|
// If asleep, wake up the computed by subscribing to any dependencies.
|
|
if (!_isDisposed && isSleeping && event == 'change') {
|
|
isSleeping = false;
|
|
if (_needsEvaluation || haveDependenciesChanged()) {
|
|
dependencyTracking = null;
|
|
_dependenciesCount = 0;
|
|
_needsEvaluation = true;
|
|
evaluateImmediate();
|
|
} else {
|
|
// First put the dependencies in order
|
|
var dependeciesOrder = [];
|
|
ko.utils.objectForEach(dependencyTracking, function (id, dependency) {
|
|
dependeciesOrder[dependency._order] = id;
|
|
});
|
|
// Next, subscribe to each one
|
|
ko.utils.arrayForEach(dependeciesOrder, function(id, order) {
|
|
var dependency = dependencyTracking[id],
|
|
subscription = dependency._target.subscribe(evaluatePossiblyAsync);
|
|
subscription._order = order;
|
|
subscription._version = dependency._version;
|
|
dependencyTracking[id] = subscription;
|
|
});
|
|
}
|
|
if (!_isDisposed) { // test since evaluating could trigger disposal
|
|
notify(_latestValue, "awake");
|
|
}
|
|
}
|
|
};
|
|
|
|
dependentObservable.afterSubscriptionRemove = function (event) {
|
|
if (!_isDisposed && event == 'change' && !dependentObservable.hasSubscriptionsForEvent('change')) {
|
|
ko.utils.objectForEach(dependencyTracking, function (id, dependency) {
|
|
if (dependency.dispose) {
|
|
dependencyTracking[id] = {
|
|
_target: dependency._target,
|
|
_order: dependency._order,
|
|
_version: dependency._version
|
|
};
|
|
dependency.dispose();
|
|
}
|
|
});
|
|
isSleeping = true;
|
|
notify(undefined, "asleep");
|
|
}
|
|
};
|
|
|
|
// Because a pure computed is not automatically updated while it is sleeping, we can't
|
|
// simply return the version number. Instead, we check if any of the dependencies have
|
|
// changed and conditionally re-evaluate the computed observable.
|
|
dependentObservable._originalGetVersion = dependentObservable.getVersion;
|
|
dependentObservable.getVersion = function () {
|
|
if (isSleeping && (_needsEvaluation || haveDependenciesChanged())) {
|
|
evaluateImmediate();
|
|
}
|
|
return dependentObservable._originalGetVersion();
|
|
};
|
|
} else if (options['deferEvaluation']) {
|
|
// This will force a computed with deferEvaluation to evaluate when the first subscriptions is registered.
|
|
dependentObservable.beforeSubscriptionAdd = function (event) {
|
|
if (event == 'change' || event == 'beforeChange') {
|
|
peek();
|
|
}
|
|
}
|
|
}
|
|
|
|
ko.exportProperty(dependentObservable, 'peek', dependentObservable.peek);
|
|
ko.exportProperty(dependentObservable, 'dispose', dependentObservable.dispose);
|
|
ko.exportProperty(dependentObservable, 'isActive', dependentObservable.isActive);
|
|
ko.exportProperty(dependentObservable, 'getDependenciesCount', dependentObservable.getDependenciesCount);
|
|
|
|
// Add a "disposeWhen" callback that, on each evaluation, disposes if the node was removed without using ko.removeNode.
|
|
if (disposeWhenNodeIsRemoved) {
|
|
// Since this computed is associated with a DOM node, and we don't want to dispose the computed
|
|
// until the DOM node is *removed* from the document (as opposed to never having been in the document),
|
|
// we'll prevent disposal until "disposeWhen" first returns false.
|
|
_suppressDisposalUntilDisposeWhenReturnsFalse = true;
|
|
|
|
// Only watch for the node's disposal if the value really is a node. It might not be,
|
|
// e.g., { disposeWhenNodeIsRemoved: true } can be used to opt into the "only dispose
|
|
// after first false result" behaviour even if there's no specific node to watch. This
|
|
// technique is intended for KO's internal use only and shouldn't be documented or used
|
|
// by application code, as it's likely to change in a future version of KO.
|
|
if (disposeWhenNodeIsRemoved.nodeType) {
|
|
disposeWhen = function () {
|
|
return !ko.utils.domNodeIsAttachedToDocument(disposeWhenNodeIsRemoved) || (disposeWhenOption && disposeWhenOption());
|
|
};
|
|
}
|
|
}
|
|
|
|
// Evaluate, unless sleeping or deferEvaluation is true
|
|
if (!isSleeping && !options['deferEvaluation'])
|
|
evaluateImmediate();
|
|
|
|
// Attach a DOM node disposal callback so that the computed will be proactively disposed as soon as the node is
|
|
// removed using ko.removeNode. But skip if isActive is false (there will never be any dependencies to dispose).
|
|
if (disposeWhenNodeIsRemoved && isActive() && disposeWhenNodeIsRemoved.nodeType) {
|
|
dispose = function() {
|
|
ko.utils.domNodeDisposal.removeDisposeCallback(disposeWhenNodeIsRemoved, dispose);
|
|
disposeComputed();
|
|
};
|
|
ko.utils.domNodeDisposal.addDisposeCallback(disposeWhenNodeIsRemoved, dispose);
|
|
}
|
|
|
|
return dependentObservable;
|
|
};
|
|
|
|
ko.isComputed = function(instance) {
|
|
return ko.hasPrototype(instance, ko.dependentObservable);
|
|
};
|
|
|
|
var protoProp = ko.observable.protoProperty; // == "__ko_proto__"
|
|
ko.dependentObservable[protoProp] = ko.observable;
|
|
|
|
ko.dependentObservable['fn'] = {
|
|
"equalityComparer": valuesArePrimitiveAndEqual
|
|
};
|
|
ko.dependentObservable['fn'][protoProp] = ko.dependentObservable;
|
|
|
|
// Note that for browsers that don't support proto assignment, the
|
|
// inheritance chain is created manually in the ko.dependentObservable constructor
|
|
if (ko.utils.canSetPrototype) {
|
|
ko.utils.setPrototypeOf(ko.dependentObservable['fn'], ko.subscribable['fn']);
|
|
}
|
|
|
|
ko.exportSymbol('dependentObservable', ko.dependentObservable);
|
|
ko.exportSymbol('computed', ko.dependentObservable); // Make "ko.computed" an alias for "ko.dependentObservable"
|
|
ko.exportSymbol('isComputed', ko.isComputed);
|
|
|
|
ko.pureComputed = function (evaluatorFunctionOrOptions, evaluatorFunctionTarget) {
|
|
if (typeof evaluatorFunctionOrOptions === 'function') {
|
|
return ko.computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget, {'pure':true});
|
|
} else {
|
|
evaluatorFunctionOrOptions = ko.utils.extend({}, evaluatorFunctionOrOptions); // make a copy of the parameter object
|
|
evaluatorFunctionOrOptions['pure'] = true;
|
|
return ko.computed(evaluatorFunctionOrOptions, evaluatorFunctionTarget);
|
|
}
|
|
}
|
|
ko.exportSymbol('pureComputed', ko.pureComputed);
|
|
|
|
(function() {
|
|
var maxNestedObservableDepth = 10; // Escape the (unlikely) pathalogical case where an observable's current value is itself (or similar reference cycle)
|
|
|
|
ko.toJS = function(rootObject) {
|
|
if (arguments.length == 0)
|
|
throw new Error("When calling ko.toJS, pass the object you want to convert.");
|
|
|
|
// We just unwrap everything at every level in the object graph
|
|
return mapJsObjectGraph(rootObject, function(valueToMap) {
|
|
// Loop because an observable's value might in turn be another observable wrapper
|
|
for (var i = 0; ko.isObservable(valueToMap) && (i < maxNestedObservableDepth); i++)
|
|
valueToMap = valueToMap();
|
|
return valueToMap;
|
|
});
|
|
};
|
|
|
|
ko.toJSON = function(rootObject, replacer, space) { // replacer and space are optional
|
|
var plainJavaScriptObject = ko.toJS(rootObject);
|
|
return ko.utils.stringifyJson(plainJavaScriptObject, replacer, space);
|
|
};
|
|
|
|
function mapJsObjectGraph(rootObject, mapInputCallback, visitedObjects) {
|
|
visitedObjects = visitedObjects || new objectLookup();
|
|
|
|
rootObject = mapInputCallback(rootObject);
|
|
var canHaveProperties = (typeof rootObject == "object") && (rootObject !== null) && (rootObject !== undefined) && (!(rootObject instanceof Date)) && (!(rootObject instanceof String)) && (!(rootObject instanceof Number)) && (!(rootObject instanceof Boolean));
|
|
if (!canHaveProperties)
|
|
return rootObject;
|
|
|
|
var outputProperties = rootObject instanceof Array ? [] : {};
|
|
visitedObjects.save(rootObject, outputProperties);
|
|
|
|
visitPropertiesOrArrayEntries(rootObject, function(indexer) {
|
|
var propertyValue = mapInputCallback(rootObject[indexer]);
|
|
|
|
switch (typeof propertyValue) {
|
|
case "boolean":
|
|
case "number":
|
|
case "string":
|
|
case "function":
|
|
outputProperties[indexer] = propertyValue;
|
|
break;
|
|
case "object":
|
|
case "undefined":
|
|
var previouslyMappedValue = visitedObjects.get(propertyValue);
|
|
outputProperties[indexer] = (previouslyMappedValue !== undefined)
|
|
? previouslyMappedValue
|
|
: mapJsObjectGraph(propertyValue, mapInputCallback, visitedObjects);
|
|
break;
|
|
}
|
|
});
|
|
|
|
return outputProperties;
|
|
}
|
|
|
|
function visitPropertiesOrArrayEntries(rootObject, visitorCallback) {
|
|
if (rootObject instanceof Array) {
|
|
for (var i = 0; i < rootObject.length; i++)
|
|
visitorCallback(i);
|
|
|
|
// For arrays, also respect toJSON property for custom mappings (fixes #278)
|
|
if (typeof rootObject['toJSON'] == 'function')
|
|
visitorCallback('toJSON');
|
|
} else {
|
|
for (var propertyName in rootObject) {
|
|
visitorCallback(propertyName);
|
|
}
|
|
}
|
|
};
|
|
|
|
function objectLookup() {
|
|
this.keys = [];
|
|
this.values = [];
|
|
};
|
|
|
|
objectLookup.prototype = {
|
|
constructor: objectLookup,
|
|
save: function(key, value) {
|
|
var existingIndex = ko.utils.arrayIndexOf(this.keys, key);
|
|
if (existingIndex >= 0)
|
|
this.values[existingIndex] = value;
|
|
else {
|
|
this.keys.push(key);
|
|
this.values.push(value);
|
|
}
|
|
},
|
|
get: function(key) {
|
|
var existingIndex = ko.utils.arrayIndexOf(this.keys, key);
|
|
return (existingIndex >= 0) ? this.values[existingIndex] : undefined;
|
|
}
|
|
};
|
|
})();
|
|
|
|
ko.exportSymbol('toJS', ko.toJS);
|
|
ko.exportSymbol('toJSON', ko.toJSON);
|
|
(function () {
|
|
var hasDomDataExpandoProperty = '__ko__hasDomDataOptionValue__';
|
|
|
|
// Normally, SELECT elements and their OPTIONs can only take value of type 'string' (because the values
|
|
// are stored on DOM attributes). ko.selectExtensions provides a way for SELECTs/OPTIONs to have values
|
|
// that are arbitrary objects. This is very convenient when implementing things like cascading dropdowns.
|
|
ko.selectExtensions = {
|
|
readValue : function(element) {
|
|
switch (ko.utils.tagNameLower(element)) {
|
|
case 'option':
|
|
if (element[hasDomDataExpandoProperty] === true)
|
|
return ko.utils.domData.get(element, ko.bindingHandlers.options.optionValueDomDataKey);
|
|
return ko.utils.ieVersion <= 7
|
|
? (element.getAttributeNode('value') && element.getAttributeNode('value').specified ? element.value : element.text)
|
|
: element.value;
|
|
case 'select':
|
|
return element.selectedIndex >= 0 ? ko.selectExtensions.readValue(element.options[element.selectedIndex]) : undefined;
|
|
default:
|
|
return element.value;
|
|
}
|
|
},
|
|
|
|
writeValue: function(element, value, allowUnset) {
|
|
switch (ko.utils.tagNameLower(element)) {
|
|
case 'option':
|
|
switch(typeof value) {
|
|
case "string":
|
|
ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, undefined);
|
|
if (hasDomDataExpandoProperty in element) { // IE <= 8 throws errors if you delete non-existent properties from a DOM node
|
|
delete element[hasDomDataExpandoProperty];
|
|
}
|
|
element.value = value;
|
|
break;
|
|
default:
|
|
// Store arbitrary object using DomData
|
|
ko.utils.domData.set(element, ko.bindingHandlers.options.optionValueDomDataKey, value);
|
|
element[hasDomDataExpandoProperty] = true;
|
|
|
|
// Special treatment of numbers is just for backward compatibility. KO 1.2.1 wrote numerical values to element.value.
|
|
element.value = typeof value === "number" ? value : "";
|
|
break;
|
|
}
|
|
break;
|
|
case 'select':
|
|
if (value === "" || value === null) // A blank string or null value will select the caption
|
|
value = undefined;
|
|
var selection = -1;
|
|
for (var i = 0, n = element.options.length, optionValue; i < n; ++i) {
|
|
optionValue = ko.selectExtensions.readValue(element.options[i]);
|
|
// Include special check to handle selecting a caption with a blank string value
|
|
if (optionValue == value || (optionValue == "" && value === undefined)) {
|
|
selection = i;
|
|
break;
|
|
}
|
|
}
|
|
if (allowUnset || selection >= 0 || (value === undefined && element.size > 1)) {
|
|
element.selectedIndex = selection;
|
|
}
|
|
break;
|
|
default:
|
|
if ((value === null) || (value === undefined))
|
|
value = "";
|
|
element.value = value;
|
|
break;
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
|
|
ko.exportSymbol('selectExtensions', ko.selectExtensions);
|
|
ko.exportSymbol('selectExtensions.readValue', ko.selectExtensions.readValue);
|
|
ko.exportSymbol('selectExtensions.writeValue', ko.selectExtensions.writeValue);
|
|
ko.expressionRewriting = (function () {
|
|
var javaScriptReservedWords = ["true", "false", "null", "undefined"];
|
|
|
|
// Matches something that can be assigned to--either an isolated identifier or something ending with a property accessor
|
|
// This is designed to be simple and avoid false negatives, but could produce false positives (e.g., a+b.c).
|
|
// This also will not properly handle nested brackets (e.g., obj1[obj2['prop']]; see #911).
|
|
var javaScriptAssignmentTarget = /^(?:[$_a-z][$\w]*|(.+)(\.\s*[$_a-z][$\w]*|\[.+\]))$/i;
|
|
|
|
function getWriteableValue(expression) {
|
|
if (ko.utils.arrayIndexOf(javaScriptReservedWords, expression) >= 0)
|
|
return false;
|
|
var match = expression.match(javaScriptAssignmentTarget);
|
|
return match === null ? false : match[1] ? ('Object(' + match[1] + ')' + match[2]) : expression;
|
|
}
|
|
|
|
// The following regular expressions will be used to split an object-literal string into tokens
|
|
|
|
// These two match strings, either with double quotes or single quotes
|
|
var stringDouble = '"(?:[^"\\\\]|\\\\.)*"',
|
|
stringSingle = "'(?:[^'\\\\]|\\\\.)*'",
|
|
// Matches a regular expression (text enclosed by slashes), but will also match sets of divisions
|
|
// as a regular expression (this is handled by the parsing loop below).
|
|
stringRegexp = '/(?:[^/\\\\]|\\\\.)*/\w*',
|
|
// These characters have special meaning to the parser and must not appear in the middle of a
|
|
// token, except as part of a string.
|
|
specials = ',"\'{}()/:[\\]',
|
|
// Match text (at least two characters) that does not contain any of the above special characters,
|
|
// although some of the special characters are allowed to start it (all but the colon and comma).
|
|
// The text can contain spaces, but leading or trailing spaces are skipped.
|
|
everyThingElse = '[^\\s:,/][^' + specials + ']*[^\\s' + specials + ']',
|
|
// Match any non-space character not matched already. This will match colons and commas, since they're
|
|
// not matched by "everyThingElse", but will also match any other single character that wasn't already
|
|
// matched (for example: in "a: 1, b: 2", each of the non-space characters will be matched by oneNotSpace).
|
|
oneNotSpace = '[^\\s]',
|
|
|
|
// Create the actual regular expression by or-ing the above strings. The order is important.
|
|
bindingToken = RegExp(stringDouble + '|' + stringSingle + '|' + stringRegexp + '|' + everyThingElse + '|' + oneNotSpace, 'g'),
|
|
|
|
// Match end of previous token to determine whether a slash is a division or regex.
|
|
divisionLookBehind = /[\])"'A-Za-z0-9_$]+$/,
|
|
keywordRegexLookBehind = {'in':1,'return':1,'typeof':1};
|
|
|
|
function parseObjectLiteral(objectLiteralString) {
|
|
// Trim leading and trailing spaces from the string
|
|
var str = ko.utils.stringTrim(objectLiteralString);
|
|
|
|
// Trim braces '{' surrounding the whole object literal
|
|
if (str.charCodeAt(0) === 123) str = str.slice(1, -1);
|
|
|
|
// Split into tokens
|
|
var result = [], toks = str.match(bindingToken), key, values = [], depth = 0;
|
|
|
|
if (toks) {
|
|
// Append a comma so that we don't need a separate code block to deal with the last item
|
|
toks.push(',');
|
|
|
|
for (var i = 0, tok; tok = toks[i]; ++i) {
|
|
var c = tok.charCodeAt(0);
|
|
// A comma signals the end of a key/value pair if depth is zero
|
|
if (c === 44) { // ","
|
|
if (depth <= 0) {
|
|
result.push((key && values.length) ? {key: key, value: values.join('')} : {'unknown': key || values.join('')});
|
|
key = depth = 0;
|
|
values = [];
|
|
continue;
|
|
}
|
|
// Simply skip the colon that separates the name and value
|
|
} else if (c === 58) { // ":"
|
|
if (!depth && !key && values.length === 1) {
|
|
key = values.pop();
|
|
continue;
|
|
}
|
|
// A set of slashes is initially matched as a regular expression, but could be division
|
|
} else if (c === 47 && i && tok.length > 1) { // "/"
|
|
// Look at the end of the previous token to determine if the slash is actually division
|
|
var match = toks[i-1].match(divisionLookBehind);
|
|
if (match && !keywordRegexLookBehind[match[0]]) {
|
|
// The slash is actually a division punctuator; re-parse the remainder of the string (not including the slash)
|
|
str = str.substr(str.indexOf(tok) + 1);
|
|
toks = str.match(bindingToken);
|
|
toks.push(',');
|
|
i = -1;
|
|
// Continue with just the slash
|
|
tok = '/';
|
|
}
|
|
// Increment depth for parentheses, braces, and brackets so that interior commas are ignored
|
|
} else if (c === 40 || c === 123 || c === 91) { // '(', '{', '['
|
|
++depth;
|
|
} else if (c === 41 || c === 125 || c === 93) { // ')', '}', ']'
|
|
--depth;
|
|
// The key will be the first token; if it's a string, trim the quotes
|
|
} else if (!key && !values.length && (c === 34 || c === 39)) { // '"', "'"
|
|
tok = tok.slice(1, -1);
|
|
}
|
|
values.push(tok);
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Two-way bindings include a write function that allow the handler to update the value even if it's not an observable.
|
|
var twoWayBindings = {};
|
|
|
|
function preProcessBindings(bindingsStringOrKeyValueArray, bindingOptions) {
|
|
bindingOptions = bindingOptions || {};
|
|
|
|
function processKeyValue(key, val) {
|
|
var writableVal;
|
|
function callPreprocessHook(obj) {
|
|
return (obj && obj['preprocess']) ? (val = obj['preprocess'](val, key, processKeyValue)) : true;
|
|
}
|
|
if (!bindingParams) {
|
|
if (!callPreprocessHook(ko['getBindingHandler'](key)))
|
|
return;
|
|
|
|
if (twoWayBindings[key] && (writableVal = getWriteableValue(val))) {
|
|
// For two-way bindings, provide a write method in case the value
|
|
// isn't a writable observable.
|
|
propertyAccessorResultStrings.push("'" + key + "':function(_z){" + writableVal + "=_z}");
|
|
}
|
|
}
|
|
// Values are wrapped in a function so that each value can be accessed independently
|
|
if (makeValueAccessors) {
|
|
val = 'function(){return ' + val + ' }';
|
|
}
|
|
resultStrings.push("'" + key + "':" + val);
|
|
}
|
|
|
|
var resultStrings = [],
|
|
propertyAccessorResultStrings = [],
|
|
makeValueAccessors = bindingOptions['valueAccessors'],
|
|
bindingParams = bindingOptions['bindingParams'],
|
|
keyValueArray = typeof bindingsStringOrKeyValueArray === "string" ?
|
|
parseObjectLiteral(bindingsStringOrKeyValueArray) : bindingsStringOrKeyValueArray;
|
|
|
|
ko.utils.arrayForEach(keyValueArray, function(keyValue) {
|
|
processKeyValue(keyValue.key || keyValue['unknown'], keyValue.value);
|
|
});
|
|
|
|
if (propertyAccessorResultStrings.length)
|
|
processKeyValue('_ko_property_writers', "{" + propertyAccessorResultStrings.join(",") + " }");
|
|
|
|
return resultStrings.join(",");
|
|
}
|
|
|
|
return {
|
|
bindingRewriteValidators: [],
|
|
|
|
twoWayBindings: twoWayBindings,
|
|
|
|
parseObjectLiteral: parseObjectLiteral,
|
|
|
|
preProcessBindings: preProcessBindings,
|
|
|
|
keyValueArrayContainsKey: function(keyValueArray, key) {
|
|
for (var i = 0; i < keyValueArray.length; i++)
|
|
if (keyValueArray[i]['key'] == key)
|
|
return true;
|
|
return false;
|
|
},
|
|
|
|
// Internal, private KO utility for updating model properties from within bindings
|
|
// property: If the property being updated is (or might be) an observable, pass it here
|
|
// If it turns out to be a writable observable, it will be written to directly
|
|
// allBindings: An object with a get method to retrieve bindings in the current execution context.
|
|
// This will be searched for a '_ko_property_writers' property in case you're writing to a non-observable
|
|
// key: The key identifying the property to be written. Example: for { hasFocus: myValue }, write to 'myValue' by specifying the key 'hasFocus'
|
|
// value: The value to be written
|
|
// checkIfDifferent: If true, and if the property being written is a writable observable, the value will only be written if
|
|
// it is !== existing value on that writable observable
|
|
writeValueToProperty: function(property, allBindings, key, value, checkIfDifferent) {
|
|
if (!property || !ko.isObservable(property)) {
|
|
var propWriters = allBindings.get('_ko_property_writers');
|
|
if (propWriters && propWriters[key])
|
|
propWriters[key](value);
|
|
} else if (ko.isWriteableObservable(property) && (!checkIfDifferent || property.peek() !== value)) {
|
|
property(value);
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
|
|
ko.exportSymbol('expressionRewriting', ko.expressionRewriting);
|
|
ko.exportSymbol('expressionRewriting.bindingRewriteValidators', ko.expressionRewriting.bindingRewriteValidators);
|
|
ko.exportSymbol('expressionRewriting.parseObjectLiteral', ko.expressionRewriting.parseObjectLiteral);
|
|
ko.exportSymbol('expressionRewriting.preProcessBindings', ko.expressionRewriting.preProcessBindings);
|
|
|
|
// Making bindings explicitly declare themselves as "two way" isn't ideal in the long term (it would be better if
|
|
// all bindings could use an official 'property writer' API without needing to declare that they might). However,
|
|
// since this is not, and has never been, a public API (_ko_property_writers was never documented), it's acceptable
|
|
// as an internal implementation detail in the short term.
|
|
// For those developers who rely on _ko_property_writers in their custom bindings, we expose _twoWayBindings as an
|
|
// undocumented feature that makes it relatively easy to upgrade to KO 3.0. However, this is still not an official
|
|
// public API, and we reserve the right to remove it at any time if we create a real public property writers API.
|
|
ko.exportSymbol('expressionRewriting._twoWayBindings', ko.expressionRewriting.twoWayBindings);
|
|
|
|
// For backward compatibility, define the following aliases. (Previously, these function names were misleading because
|
|
// they referred to JSON specifically, even though they actually work with arbitrary JavaScript object literal expressions.)
|
|
ko.exportSymbol('jsonExpressionRewriting', ko.expressionRewriting);
|
|
ko.exportSymbol('jsonExpressionRewriting.insertPropertyAccessorsIntoJson', ko.expressionRewriting.preProcessBindings);
|
|
(function() {
|
|
// "Virtual elements" is an abstraction on top of the usual DOM API which understands the notion that comment nodes
|
|
// may be used to represent hierarchy (in addition to the DOM's natural hierarchy).
|
|
// If you call the DOM-manipulating functions on ko.virtualElements, you will be able to read and write the state
|
|
// of that virtual hierarchy
|
|
//
|
|
// The point of all this is to support containerless templates (e.g., <!-- ko foreach:someCollection -->blah<!-- /ko -->)
|
|
// without having to scatter special cases all over the binding and templating code.
|
|
|
|
// IE 9 cannot reliably read the "nodeValue" property of a comment node (see https://github.com/SteveSanderson/knockout/issues/186)
|
|
// but it does give them a nonstandard alternative property called "text" that it can read reliably. Other browsers don't have that property.
|
|
// So, use node.text where available, and node.nodeValue elsewhere
|
|
var commentNodesHaveTextProperty = document && document.createComment("test").text === "<!--test-->";
|
|
|
|
var startCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*ko(?:\s+([\s\S]+))?\s*-->$/ : /^\s*ko(?:\s+([\s\S]+))?\s*$/;
|
|
var endCommentRegex = commentNodesHaveTextProperty ? /^<!--\s*\/ko\s*-->$/ : /^\s*\/ko\s*$/;
|
|
var htmlTagsWithOptionallyClosingChildren = { 'ul': true, 'ol': true };
|
|
|
|
function isStartComment(node) {
|
|
return (node.nodeType == 8) && startCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
|
|
}
|
|
|
|
function isEndComment(node) {
|
|
return (node.nodeType == 8) && endCommentRegex.test(commentNodesHaveTextProperty ? node.text : node.nodeValue);
|
|
}
|
|
|
|
function getVirtualChildren(startComment, allowUnbalanced) {
|
|
var currentNode = startComment;
|
|
var depth = 1;
|
|
var children = [];
|
|
while (currentNode = currentNode.nextSibling) {
|
|
if (isEndComment(currentNode)) {
|
|
depth--;
|
|
if (depth === 0)
|
|
return children;
|
|
}
|
|
|
|
children.push(currentNode);
|
|
|
|
if (isStartComment(currentNode))
|
|
depth++;
|
|
}
|
|
if (!allowUnbalanced)
|
|
throw new Error("Cannot find closing comment tag to match: " + startComment.nodeValue);
|
|
return null;
|
|
}
|
|
|
|
function getMatchingEndComment(startComment, allowUnbalanced) {
|
|
var allVirtualChildren = getVirtualChildren(startComment, allowUnbalanced);
|
|
if (allVirtualChildren) {
|
|
if (allVirtualChildren.length > 0)
|
|
return allVirtualChildren[allVirtualChildren.length - 1].nextSibling;
|
|
return startComment.nextSibling;
|
|
} else
|
|
return null; // Must have no matching end comment, and allowUnbalanced is true
|
|
}
|
|
|
|
function getUnbalancedChildTags(node) {
|
|
// e.g., from <div>OK</div><!-- ko blah --><span>Another</span>, returns: <!-- ko blah --><span>Another</span>
|
|
// from <div>OK</div><!-- /ko --><!-- /ko -->, returns: <!-- /ko --><!-- /ko -->
|
|
var childNode = node.firstChild, captureRemaining = null;
|
|
if (childNode) {
|
|
do {
|
|
if (captureRemaining) // We already hit an unbalanced node and are now just scooping up all subsequent nodes
|
|
captureRemaining.push(childNode);
|
|
else if (isStartComment(childNode)) {
|
|
var matchingEndComment = getMatchingEndComment(childNode, /* allowUnbalanced: */ true);
|
|
if (matchingEndComment) // It's a balanced tag, so skip immediately to the end of this virtual set
|
|
childNode = matchingEndComment;
|
|
else
|
|
captureRemaining = [childNode]; // It's unbalanced, so start capturing from this point
|
|
} else if (isEndComment(childNode)) {
|
|
captureRemaining = [childNode]; // It's unbalanced (if it wasn't, we'd have skipped over it already), so start capturing
|
|
}
|
|
} while (childNode = childNode.nextSibling);
|
|
}
|
|
return captureRemaining;
|
|
}
|
|
|
|
ko.virtualElements = {
|
|
allowedBindings: {},
|
|
|
|
childNodes: function(node) {
|
|
return isStartComment(node) ? getVirtualChildren(node) : node.childNodes;
|
|
},
|
|
|
|
emptyNode: function(node) {
|
|
if (!isStartComment(node))
|
|
ko.utils.emptyDomNode(node);
|
|
else {
|
|
var virtualChildren = ko.virtualElements.childNodes(node);
|
|
for (var i = 0, j = virtualChildren.length; i < j; i++)
|
|
ko.removeNode(virtualChildren[i]);
|
|
}
|
|
},
|
|
|
|
setDomNodeChildren: function(node, childNodes) {
|
|
if (!isStartComment(node))
|
|
ko.utils.setDomNodeChildren(node, childNodes);
|
|
else {
|
|
ko.virtualElements.emptyNode(node);
|
|
var endCommentNode = node.nextSibling; // Must be the next sibling, as we just emptied the children
|
|
for (var i = 0, j = childNodes.length; i < j; i++)
|
|
endCommentNode.parentNode.insertBefore(childNodes[i], endCommentNode);
|
|
}
|
|
},
|
|
|
|
prepend: function(containerNode, nodeToPrepend) {
|
|
if (!isStartComment(containerNode)) {
|
|
if (containerNode.firstChild)
|
|
containerNode.insertBefore(nodeToPrepend, containerNode.firstChild);
|
|
else
|
|
containerNode.appendChild(nodeToPrepend);
|
|
} else {
|
|
// Start comments must always have a parent and at least one following sibling (the end comment)
|
|
containerNode.parentNode.insertBefore(nodeToPrepend, containerNode.nextSibling);
|
|
}
|
|
},
|
|
|
|
insertAfter: function(containerNode, nodeToInsert, insertAfterNode) {
|
|
if (!insertAfterNode) {
|
|
ko.virtualElements.prepend(containerNode, nodeToInsert);
|
|
} else if (!isStartComment(containerNode)) {
|
|
// Insert after insertion point
|
|
if (insertAfterNode.nextSibling)
|
|
containerNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
|
|
else
|
|
containerNode.appendChild(nodeToInsert);
|
|
} else {
|
|
// Children of start comments must always have a parent and at least one following sibling (the end comment)
|
|
containerNode.parentNode.insertBefore(nodeToInsert, insertAfterNode.nextSibling);
|
|
}
|
|
},
|
|
|
|
firstChild: function(node) {
|
|
if (!isStartComment(node))
|
|
return node.firstChild;
|
|
if (!node.nextSibling || isEndComment(node.nextSibling))
|
|
return null;
|
|
return node.nextSibling;
|
|
},
|
|
|
|
nextSibling: function(node) {
|
|
if (isStartComment(node))
|
|
node = getMatchingEndComment(node);
|
|
if (node.nextSibling && isEndComment(node.nextSibling))
|
|
return null;
|
|
return node.nextSibling;
|
|
},
|
|
|
|
hasBindingValue: isStartComment,
|
|
|
|
virtualNodeBindingValue: function(node) {
|
|
var regexMatch = (commentNodesHaveTextProperty ? node.text : node.nodeValue).match(startCommentRegex);
|
|
return regexMatch ? regexMatch[1] : null;
|
|
},
|
|
|
|
normaliseVirtualElementDomStructure: function(elementVerified) {
|
|
// Workaround for https://github.com/SteveSanderson/knockout/issues/155
|
|
// (IE <= 8 or IE 9 quirks mode parses your HTML weirdly, treating closing </li> tags as if they don't exist, thereby moving comment nodes
|
|
// that are direct descendants of <ul> into the preceding <li>)
|
|
if (!htmlTagsWithOptionallyClosingChildren[ko.utils.tagNameLower(elementVerified)])
|
|
return;
|
|
|
|
// Scan immediate children to see if they contain unbalanced comment tags. If they do, those comment tags
|
|
// must be intended to appear *after* that child, so move them there.
|
|
var childNode = elementVerified.firstChild;
|
|
if (childNode) {
|
|
do {
|
|
if (childNode.nodeType === 1) {
|
|
var unbalancedTags = getUnbalancedChildTags(childNode);
|
|
if (unbalancedTags) {
|
|
// Fix up the DOM by moving the unbalanced tags to where they most likely were intended to be placed - *after* the child
|
|
var nodeToInsertBefore = childNode.nextSibling;
|
|
for (var i = 0; i < unbalancedTags.length; i++) {
|
|
if (nodeToInsertBefore)
|
|
elementVerified.insertBefore(unbalancedTags[i], nodeToInsertBefore);
|
|
else
|
|
elementVerified.appendChild(unbalancedTags[i]);
|
|
}
|
|
}
|
|
}
|
|
} while (childNode = childNode.nextSibling);
|
|
}
|
|
}
|
|
};
|
|
})();
|
|
ko.exportSymbol('virtualElements', ko.virtualElements);
|
|
ko.exportSymbol('virtualElements.allowedBindings', ko.virtualElements.allowedBindings);
|
|
ko.exportSymbol('virtualElements.emptyNode', ko.virtualElements.emptyNode);
|
|
//ko.exportSymbol('virtualElements.firstChild', ko.virtualElements.firstChild); // firstChild is not minified
|
|
ko.exportSymbol('virtualElements.insertAfter', ko.virtualElements.insertAfter);
|
|
//ko.exportSymbol('virtualElements.nextSibling', ko.virtualElements.nextSibling); // nextSibling is not minified
|
|
ko.exportSymbol('virtualElements.prepend', ko.virtualElements.prepend);
|
|
ko.exportSymbol('virtualElements.setDomNodeChildren', ko.virtualElements.setDomNodeChildren);
|
|
(function() {
|
|
var defaultBindingAttributeName = "data-bind";
|
|
|
|
ko.bindingProvider = function() {
|
|
this.bindingCache = {};
|
|
};
|
|
|
|
ko.utils.extend(ko.bindingProvider.prototype, {
|
|
'nodeHasBindings': function(node) {
|
|
switch (node.nodeType) {
|
|
case 1: // Element
|
|
return node.getAttribute(defaultBindingAttributeName) != null
|
|
|| ko.components['getComponentNameForNode'](node);
|
|
case 8: // Comment node
|
|
return ko.virtualElements.hasBindingValue(node);
|
|
default: return false;
|
|
}
|
|
},
|
|
|
|
'getBindings': function(node, bindingContext) {
|
|
var bindingsString = this['getBindingsString'](node, bindingContext),
|
|
parsedBindings = bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node) : null;
|
|
return ko.components.addBindingsForCustomElement(parsedBindings, node, bindingContext, /* valueAccessors */ false);
|
|
},
|
|
|
|
'getBindingAccessors': function(node, bindingContext) {
|
|
var bindingsString = this['getBindingsString'](node, bindingContext),
|
|
parsedBindings = bindingsString ? this['parseBindingsString'](bindingsString, bindingContext, node, { 'valueAccessors': true }) : null;
|
|
return ko.components.addBindingsForCustomElement(parsedBindings, node, bindingContext, /* valueAccessors */ true);
|
|
},
|
|
|
|
// The following function is only used internally by this default provider.
|
|
// It's not part of the interface definition for a general binding provider.
|
|
'getBindingsString': function(node, bindingContext) {
|
|
switch (node.nodeType) {
|
|
case 1: return node.getAttribute(defaultBindingAttributeName); // Element
|
|
case 8: return ko.virtualElements.virtualNodeBindingValue(node); // Comment node
|
|
default: return null;
|
|
}
|
|
},
|
|
|
|
// The following function is only used internally by this default provider.
|
|
// It's not part of the interface definition for a general binding provider.
|
|
'parseBindingsString': function(bindingsString, bindingContext, node, options) {
|
|
try {
|
|
var bindingFunction = createBindingsStringEvaluatorViaCache(bindingsString, this.bindingCache, options);
|
|
return bindingFunction(bindingContext, node);
|
|
} catch (ex) {
|
|
ex.message = "Unable to parse bindings.\nBindings value: " + bindingsString + "\nMessage: " + ex.message;
|
|
throw ex;
|
|
}
|
|
}
|
|
});
|
|
|
|
ko.bindingProvider['instance'] = new ko.bindingProvider();
|
|
|
|
function createBindingsStringEvaluatorViaCache(bindingsString, cache, options) {
|
|
var cacheKey = bindingsString + (options && options['valueAccessors'] || '');
|
|
return cache[cacheKey]
|
|
|| (cache[cacheKey] = createBindingsStringEvaluator(bindingsString, options));
|
|
}
|
|
|
|
function createBindingsStringEvaluator(bindingsString, options) {
|
|
// Build the source for a function that evaluates "expression"
|
|
// For each scope variable, add an extra level of "with" nesting
|
|
// Example result: with(sc1) { with(sc0) { return (expression) } }
|
|
var rewrittenBindings = ko.expressionRewriting.preProcessBindings(bindingsString, options),
|
|
functionBody = "with($context){with($data||{}){return{" + rewrittenBindings + "}}}";
|
|
return new Function("$context", "$element", functionBody);
|
|
}
|
|
})();
|
|
|
|
ko.exportSymbol('bindingProvider', ko.bindingProvider);
|
|
(function () {
|
|
ko.bindingHandlers = {};
|
|
|
|
// The following element types will not be recursed into during binding. In the future, we
|
|
// may consider adding <template> to this list, because such elements' contents are always
|
|
// intended to be bound in a different context from where they appear in the document.
|
|
var bindingDoesNotRecurseIntoElementTypes = {
|
|
// Don't want bindings that operate on text nodes to mutate <script> and <textarea> contents,
|
|
// because it's unexpected and a potential XSS issue
|
|
'script': true,
|
|
'textarea': true
|
|
};
|
|
|
|
// Use an overridable method for retrieving binding handlers so that a plugins may support dynamically created handlers
|
|
ko['getBindingHandler'] = function(bindingKey) {
|
|
return ko.bindingHandlers[bindingKey];
|
|
};
|
|
|
|
// The ko.bindingContext constructor is only called directly to create the root context. For child
|
|
// contexts, use bindingContext.createChildContext or bindingContext.extend.
|
|
ko.bindingContext = function(dataItemOrAccessor, parentContext, dataItemAlias, extendCallback) {
|
|
|
|
// The binding context object includes static properties for the current, parent, and root view models.
|
|
// If a view model is actually stored in an observable, the corresponding binding context object, and
|
|
// any child contexts, must be updated when the view model is changed.
|
|
function updateContext() {
|
|
// Most of the time, the context will directly get a view model object, but if a function is given,
|
|
// we call the function to retrieve the view model. If the function accesses any obsevables or returns
|
|
// an observable, the dependency is tracked, and those observables can later cause the binding
|
|
// context to be updated.
|
|
var dataItemOrObservable = isFunc ? dataItemOrAccessor() : dataItemOrAccessor,
|
|
dataItem = ko.utils.unwrapObservable(dataItemOrObservable);
|
|
|
|
if (parentContext) {
|
|
// When a "parent" context is given, register a dependency on the parent context. Thus whenever the
|
|
// parent context is updated, this context will also be updated.
|
|
if (parentContext._subscribable)
|
|
parentContext._subscribable();
|
|
|
|
// Copy $root and any custom properties from the parent context
|
|
ko.utils.extend(self, parentContext);
|
|
|
|
// Because the above copy overwrites our own properties, we need to reset them.
|
|
// During the first execution, "subscribable" isn't set, so don't bother doing the update then.
|
|
if (subscribable) {
|
|
self._subscribable = subscribable;
|
|
}
|
|
} else {
|
|
self['$parents'] = [];
|
|
self['$root'] = dataItem;
|
|
|
|
// Export 'ko' in the binding context so it will be available in bindings and templates
|
|
// even if 'ko' isn't exported as a global, such as when using an AMD loader.
|
|
// See https://github.com/SteveSanderson/knockout/issues/490
|
|
self['ko'] = ko;
|
|
}
|
|
self['$rawData'] = dataItemOrObservable;
|
|
self['$data'] = dataItem;
|
|
if (dataItemAlias)
|
|
self[dataItemAlias] = dataItem;
|
|
|
|
// The extendCallback function is provided when creating a child context or extending a context.
|
|
// It handles the specific actions needed to finish setting up the binding context. Actions in this
|
|
// function could also add dependencies to this binding context.
|
|
if (extendCallback)
|
|
extendCallback(self, parentContext, dataItem);
|
|
|
|
return self['$data'];
|
|
}
|
|
function disposeWhen() {
|
|
return nodes && !ko.utils.anyDomNodeIsAttachedToDocument(nodes);
|
|
}
|
|
|
|
var self = this,
|
|
isFunc = typeof(dataItemOrAccessor) == "function" && !ko.isObservable(dataItemOrAccessor),
|
|
nodes,
|
|
subscribable = ko.dependentObservable(updateContext, null, { disposeWhen: disposeWhen, disposeWhenNodeIsRemoved: true });
|
|
|
|
// At this point, the binding context has been initialized, and the "subscribable" computed observable is
|
|
// subscribed to any observables that were accessed in the process. If there is nothing to track, the
|
|
// computed will be inactive, and we can safely throw it away. If it's active, the computed is stored in
|
|
// the context object.
|
|
if (subscribable.isActive()) {
|
|
self._subscribable = subscribable;
|
|
|
|
// Always notify because even if the model ($data) hasn't changed, other context properties might have changed
|
|
subscribable['equalityComparer'] = null;
|
|
|
|
// We need to be able to dispose of this computed observable when it's no longer needed. This would be
|
|
// easy if we had a single node to watch, but binding contexts can be used by many different nodes, and
|
|
// we cannot assume that those nodes have any relation to each other. So instead we track any node that
|
|
// the context is attached to, and dispose the computed when all of those nodes have been cleaned.
|
|
|
|
// Add properties to *subscribable* instead of *self* because any properties added to *self* may be overwritten on updates
|
|
nodes = [];
|
|
subscribable._addNode = function(node) {
|
|
nodes.push(node);
|
|
ko.utils.domNodeDisposal.addDisposeCallback(node, function(node) {
|
|
ko.utils.arrayRemoveItem(nodes, node);
|
|
if (!nodes.length) {
|
|
subscribable.dispose();
|
|
self._subscribable = subscribable = undefined;
|
|
}
|
|
});
|
|
};
|
|
}
|
|
}
|
|
|
|
// Extend the binding context hierarchy with a new view model object. If the parent context is watching
|
|
// any obsevables, the new child context will automatically get a dependency on the parent context.
|
|
// But this does not mean that the $data value of the child context will also get updated. If the child
|
|
// view model also depends on the parent view model, you must provide a function that returns the correct
|
|
// view model on each update.
|
|
ko.bindingContext.prototype['createChildContext'] = function (dataItemOrAccessor, dataItemAlias, extendCallback) {
|
|
return new ko.bindingContext(dataItemOrAccessor, this, dataItemAlias, function(self, parentContext) {
|
|
// Extend the context hierarchy by setting the appropriate pointers
|
|
self['$parentContext'] = parentContext;
|
|
self['$parent'] = parentContext['$data'];
|
|
self['$parents'] = (parentContext['$parents'] || []).slice(0);
|
|
self['$parents'].unshift(self['$parent']);
|
|
if (extendCallback)
|
|
extendCallback(self);
|
|
});
|
|
};
|
|
|
|
// Extend the binding context with new custom properties. This doesn't change the context hierarchy.
|
|
// Similarly to "child" contexts, provide a function here to make sure that the correct values are set
|
|
// when an observable view model is updated.
|
|
ko.bindingContext.prototype['extend'] = function(properties) {
|
|
// If the parent context references an observable view model, "_subscribable" will always be the
|
|
// latest view model object. If not, "_subscribable" isn't set, and we can use the static "$data" value.
|
|
return new ko.bindingContext(this._subscribable || this['$data'], this, null, function(self, parentContext) {
|
|
// This "child" context doesn't directly track a parent observable view model,
|
|
// so we need to manually set the $rawData value to match the parent.
|
|
self['$rawData'] = parentContext['$rawData'];
|
|
ko.utils.extend(self, typeof(properties) == "function" ? properties() : properties);
|
|
});
|
|
};
|
|
|
|
// Returns the valueAccesor function for a binding value
|
|
function makeValueAccessor(value) {
|
|
return function() {
|
|
return value;
|
|
};
|
|
}
|
|
|
|
// Returns the value of a valueAccessor function
|
|
function evaluateValueAccessor(valueAccessor) {
|
|
return valueAccessor();
|
|
}
|
|
|
|
// Given a function that returns bindings, create and return a new object that contains
|
|
// binding value-accessors functions. Each accessor function calls the original function
|
|
// so that it always gets the latest value and all dependencies are captured. This is used
|
|
// by ko.applyBindingsToNode and getBindingsAndMakeAccessors.
|
|
function makeAccessorsFromFunction(callback) {
|
|
return ko.utils.objectMap(ko.dependencyDetection.ignore(callback), function(value, key) {
|
|
return function() {
|
|
return callback()[key];
|
|
};
|
|
});
|
|
}
|
|
|
|
// Given a bindings function or object, create and return a new object that contains
|
|
// binding value-accessors functions. This is used by ko.applyBindingsToNode.
|
|
function makeBindingAccessors(bindings, context, node) {
|
|
if (typeof bindings === 'function') {
|
|
return makeAccessorsFromFunction(bindings.bind(null, context, node));
|
|
} else {
|
|
return ko.utils.objectMap(bindings, makeValueAccessor);
|
|
}
|
|
}
|
|
|
|
// This function is used if the binding provider doesn't include a getBindingAccessors function.
|
|
// It must be called with 'this' set to the provider instance.
|
|
function getBindingsAndMakeAccessors(node, context) {
|
|
return makeAccessorsFromFunction(this['getBindings'].bind(this, node, context));
|
|
}
|
|
|
|
function validateThatBindingIsAllowedForVirtualElements(bindingName) {
|
|
var validator = ko.virtualElements.allowedBindings[bindingName];
|
|
if (!validator)
|
|
throw new Error("The binding '" + bindingName + "' cannot be used with virtual elements")
|
|
}
|
|
|
|
function applyBindingsToDescendantsInternal (bindingContext, elementOrVirtualElement, bindingContextsMayDifferFromDomParentElement) {
|
|
var currentChild,
|
|
nextInQueue = ko.virtualElements.firstChild(elementOrVirtualElement),
|
|
provider = ko.bindingProvider['instance'],
|
|
preprocessNode = provider['preprocessNode'];
|
|
|
|
// Preprocessing allows a binding provider to mutate a node before bindings are applied to it. For example it's
|
|
// possible to insert new siblings after it, and/or replace the node with a different one. This can be used to
|
|
// implement custom binding syntaxes, such as {{ value }} for string interpolation, or custom element types that
|
|
// trigger insertion of <template> contents at that point in the document.
|
|
if (preprocessNode) {
|
|
while (currentChild = nextInQueue) {
|
|
nextInQueue = ko.virtualElements.nextSibling(currentChild);
|
|
preprocessNode.call(provider, currentChild);
|
|
}
|
|
// Reset nextInQueue for the next loop
|
|
nextInQueue = ko.virtualElements.firstChild(elementOrVirtualElement);
|
|
}
|
|
|
|
while (currentChild = nextInQueue) {
|
|
// Keep a record of the next child *before* applying bindings, in case the binding removes the current child from its position
|
|
nextInQueue = ko.virtualElements.nextSibling(currentChild);
|
|
applyBindingsToNodeAndDescendantsInternal(bindingContext, currentChild, bindingContextsMayDifferFromDomParentElement);
|
|
}
|
|
}
|
|
|
|
function applyBindingsToNodeAndDescendantsInternal (bindingContext, nodeVerified, bindingContextMayDifferFromDomParentElement) {
|
|
var shouldBindDescendants = true;
|
|
|
|
// Perf optimisation: Apply bindings only if...
|
|
// (1) We need to store the binding context on this node (because it may differ from the DOM parent node's binding context)
|
|
// Note that we can't store binding contexts on non-elements (e.g., text nodes), as IE doesn't allow expando properties for those
|
|
// (2) It might have bindings (e.g., it has a data-bind attribute, or it's a marker for a containerless template)
|
|
var isElement = (nodeVerified.nodeType === 1);
|
|
if (isElement) // Workaround IE <= 8 HTML parsing weirdness
|
|
ko.virtualElements.normaliseVirtualElementDomStructure(nodeVerified);
|
|
|
|
var shouldApplyBindings = (isElement && bindingContextMayDifferFromDomParentElement) // Case (1)
|
|
|| ko.bindingProvider['instance']['nodeHasBindings'](nodeVerified); // Case (2)
|
|
if (shouldApplyBindings)
|
|
shouldBindDescendants = applyBindingsToNodeInternal(nodeVerified, null, bindingContext, bindingContextMayDifferFromDomParentElement)['shouldBindDescendants'];
|
|
|
|
if (shouldBindDescendants && !bindingDoesNotRecurseIntoElementTypes[ko.utils.tagNameLower(nodeVerified)]) {
|
|
// We're recursing automatically into (real or virtual) child nodes without changing binding contexts. So,
|
|
// * For children of a *real* element, the binding context is certainly the same as on their DOM .parentNode,
|
|
// hence bindingContextsMayDifferFromDomParentElement is false
|
|
// * For children of a *virtual* element, we can't be sure. Evaluating .parentNode on those children may
|
|
// skip over any number of intermediate virtual elements, any of which might define a custom binding context,
|
|
// hence bindingContextsMayDifferFromDomParentElement is true
|
|
applyBindingsToDescendantsInternal(bindingContext, nodeVerified, /* bindingContextsMayDifferFromDomParentElement: */ !isElement);
|
|
}
|
|
}
|
|
|
|
var boundElementDomDataKey = ko.utils.domData.nextKey();
|
|
|
|
|
|
function topologicalSortBindings(bindings) {
|
|
// Depth-first sort
|
|
var result = [], // The list of key/handler pairs that we will return
|
|
bindingsConsidered = {}, // A temporary record of which bindings are already in 'result'
|
|
cyclicDependencyStack = []; // Keeps track of a depth-search so that, if there's a cycle, we know which bindings caused it
|
|
ko.utils.objectForEach(bindings, function pushBinding(bindingKey) {
|
|
if (!bindingsConsidered[bindingKey]) {
|
|
var binding = ko['getBindingHandler'](bindingKey);
|
|
if (binding) {
|
|
// First add dependencies (if any) of the current binding
|
|
if (binding['after']) {
|
|
cyclicDependencyStack.push(bindingKey);
|
|
ko.utils.arrayForEach(binding['after'], function(bindingDependencyKey) {
|
|
if (bindings[bindingDependencyKey]) {
|
|
if (ko.utils.arrayIndexOf(cyclicDependencyStack, bindingDependencyKey) !== -1) {
|
|
throw Error("Cannot combine the following bindings, because they have a cyclic dependency: " + cyclicDependencyStack.join(", "));
|
|
} else {
|
|
pushBinding(bindingDependencyKey);
|
|
}
|
|
}
|
|
});
|
|
cyclicDependencyStack.length--;
|
|
}
|
|
// Next add the current binding
|
|
result.push({ key: bindingKey, handler: binding });
|
|
}
|
|
bindingsConsidered[bindingKey] = true;
|
|
}
|
|
});
|
|
|
|
return result;
|
|
}
|
|
|
|
function applyBindingsToNodeInternal(node, sourceBindings, bindingContext, bindingContextMayDifferFromDomParentElement) {
|
|
// Prevent multiple applyBindings calls for the same node, except when a binding value is specified
|
|
var alreadyBound = ko.utils.domData.get(node, boundElementDomDataKey);
|
|
if (!sourceBindings) {
|
|
if (alreadyBound) {
|
|
throw Error("You cannot apply bindings multiple times to the same element.");
|
|
}
|
|
ko.utils.domData.set(node, boundElementDomDataKey, true);
|
|
}
|
|
|
|
// Optimization: Don't store the binding context on this node if it's definitely the same as on node.parentNode, because
|
|
// we can easily recover it just by scanning up the node's ancestors in the DOM
|
|
// (note: here, parent node means "real DOM parent" not "virtual parent", as there's no O(1) way to find the virtual parent)
|
|
if (!alreadyBound && bindingContextMayDifferFromDomParentElement)
|
|
ko.storedBindingContextForNode(node, bindingContext);
|
|
|
|
// Use bindings if given, otherwise fall back on asking the bindings provider to give us some bindings
|
|
var bindings;
|
|
if (sourceBindings && typeof sourceBindings !== 'function') {
|
|
bindings = sourceBindings;
|
|
} else {
|
|
var provider = ko.bindingProvider['instance'],
|
|
getBindings = provider['getBindingAccessors'] || getBindingsAndMakeAccessors;
|
|
|
|
// Get the binding from the provider within a computed observable so that we can update the bindings whenever
|
|
// the binding context is updated or if the binding provider accesses observables.
|
|
var bindingsUpdater = ko.dependentObservable(
|
|
function() {
|
|
bindings = sourceBindings ? sourceBindings(bindingContext, node) : getBindings.call(provider, node, bindingContext);
|
|
// Register a dependency on the binding context to support obsevable view models.
|
|
if (bindings && bindingContext._subscribable)
|
|
bindingContext._subscribable();
|
|
return bindings;
|
|
},
|
|
null, { disposeWhenNodeIsRemoved: node }
|
|
);
|
|
|
|
if (!bindings || !bindingsUpdater.isActive())
|
|
bindingsUpdater = null;
|
|
}
|
|
|
|
var bindingHandlerThatControlsDescendantBindings;
|
|
if (bindings) {
|
|
// Return the value accessor for a given binding. When bindings are static (won't be updated because of a binding
|
|
// context update), just return the value accessor from the binding. Otherwise, return a function that always gets
|
|
// the latest binding value and registers a dependency on the binding updater.
|
|
var getValueAccessor = bindingsUpdater
|
|
? function(bindingKey) {
|
|
return function() {
|
|
return evaluateValueAccessor(bindingsUpdater()[bindingKey]);
|
|
};
|
|
} : function(bindingKey) {
|
|
return bindings[bindingKey];
|
|
};
|
|
|
|
// Use of allBindings as a function is maintained for backwards compatibility, but its use is deprecated
|
|
function allBindings() {
|
|
return ko.utils.objectMap(bindingsUpdater ? bindingsUpdater() : bindings, evaluateValueAccessor);
|
|
}
|
|
// The following is the 3.x allBindings API
|
|
allBindings['get'] = function(key) {
|
|
return bindings[key] && evaluateValueAccessor(getValueAccessor(key));
|
|
};
|
|
allBindings['has'] = function(key) {
|
|
return key in bindings;
|
|
};
|
|
|
|
// First put the bindings into the right order
|
|
var orderedBindings = topologicalSortBindings(bindings);
|
|
|
|
// Go through the sorted bindings, calling init and update for each
|
|
ko.utils.arrayForEach(orderedBindings, function(bindingKeyAndHandler) {
|
|
// Note that topologicalSortBindings has already filtered out any nonexistent binding handlers,
|
|
// so bindingKeyAndHandler.handler will always be nonnull.
|
|
var handlerInitFn = bindingKeyAndHandler.handler["init"],
|
|
handlerUpdateFn = bindingKeyAndHandler.handler["update"],
|
|
bindingKey = bindingKeyAndHandler.key;
|
|
|
|
if (node.nodeType === 8) {
|
|
validateThatBindingIsAllowedForVirtualElements(bindingKey);
|
|
}
|
|
|
|
try {
|
|
// Run init, ignoring any dependencies
|
|
if (typeof handlerInitFn == "function") {
|
|
ko.dependencyDetection.ignore(function() {
|
|
var initResult = handlerInitFn(node, getValueAccessor(bindingKey), allBindings, bindingContext['$data'], bindingContext);
|
|
|
|
// If this binding handler claims to control descendant bindings, make a note of this
|
|
if (initResult && initResult['controlsDescendantBindings']) {
|
|
if (bindingHandlerThatControlsDescendantBindings !== undefined)
|
|
throw new Error("Multiple bindings (" + bindingHandlerThatControlsDescendantBindings + " and " + bindingKey + ") are trying to control descendant bindings of the same element. You cannot use these bindings together on the same element.");
|
|
bindingHandlerThatControlsDescendantBindings = bindingKey;
|
|
}
|
|
});
|
|
}
|
|
|
|
// Run update in its own computed wrapper
|
|
if (typeof handlerUpdateFn == "function") {
|
|
ko.dependentObservable(
|
|
function() {
|
|
handlerUpdateFn(node, getValueAccessor(bindingKey), allBindings, bindingContext['$data'], bindingContext);
|
|
},
|
|
null,
|
|
{ disposeWhenNodeIsRemoved: node }
|
|
);
|
|
}
|
|
} catch (ex) {
|
|
ex.message = "Unable to process binding \"" + bindingKey + ": " + bindings[bindingKey] + "\"\nMessage: " + ex.message;
|
|
throw ex;
|
|
}
|
|
});
|
|
}
|
|
|
|
return {
|
|
'shouldBindDescendants': bindingHandlerThatControlsDescendantBindings === undefined
|
|
};
|
|
};
|
|
|
|
var storedBindingContextDomDataKey = ko.utils.domData.nextKey();
|
|
ko.storedBindingContextForNode = function (node, bindingContext) {
|
|
if (arguments.length == 2) {
|
|
ko.utils.domData.set(node, storedBindingContextDomDataKey, bindingContext);
|
|
if (bindingContext._subscribable)
|
|
bindingContext._subscribable._addNode(node);
|
|
} else {
|
|
return ko.utils.domData.get(node, storedBindingContextDomDataKey);
|
|
}
|
|
}
|
|
|
|
function getBindingContext(viewModelOrBindingContext) {
|
|
return viewModelOrBindingContext && (viewModelOrBindingContext instanceof ko.bindingContext)
|
|
? viewModelOrBindingContext
|
|
: new ko.bindingContext(viewModelOrBindingContext);
|
|
}
|
|
|
|
ko.applyBindingAccessorsToNode = function (node, bindings, viewModelOrBindingContext) {
|
|
if (node.nodeType === 1) // If it's an element, workaround IE <= 8 HTML parsing weirdness
|
|
ko.virtualElements.normaliseVirtualElementDomStructure(node);
|
|
return applyBindingsToNodeInternal(node, bindings, getBindingContext(viewModelOrBindingContext), true);
|
|
};
|
|
|
|
ko.applyBindingsToNode = function (node, bindings, viewModelOrBindingContext) {
|
|
var context = getBindingContext(viewModelOrBindingContext);
|
|
return ko.applyBindingAccessorsToNode(node, makeBindingAccessors(bindings, context, node), context);
|
|
};
|
|
|
|
ko.applyBindingsToDescendants = function(viewModelOrBindingContext, rootNode) {
|
|
if (rootNode.nodeType === 1 || rootNode.nodeType === 8)
|
|
applyBindingsToDescendantsInternal(getBindingContext(viewModelOrBindingContext), rootNode, true);
|
|
};
|
|
|
|
ko.applyBindings = function (viewModelOrBindingContext, rootNode) {
|
|
// If jQuery is loaded after Knockout, we won't initially have access to it. So save it here.
|
|
if (!jQueryInstance && window['jQuery']) {
|
|
jQueryInstance = window['jQuery'];
|
|
}
|
|
|
|
if (rootNode && (rootNode.nodeType !== 1) && (rootNode.nodeType !== 8))
|
|
throw new Error("ko.applyBindings: first parameter should be your view model; second parameter should be a DOM node");
|
|
rootNode = rootNode || window.document.body; // Make "rootNode" parameter optional
|
|
|
|
applyBindingsToNodeAndDescendantsInternal(getBindingContext(viewModelOrBindingContext), rootNode, true);
|
|
};
|
|
|
|
// Retrieving binding context from arbitrary nodes
|
|
ko.contextFor = function(node) {
|
|
// We can only do something meaningful for elements and comment nodes (in particular, not text nodes, as IE can't store domdata for them)
|
|
switch (node.nodeType) {
|
|
case 1:
|
|
case 8:
|
|
var context = ko.storedBindingContextForNode(node);
|
|
if (context) return context;
|
|
if (node.parentNode) return ko.contextFor(node.parentNode);
|
|
break;
|
|
}
|
|
return undefined;
|
|
};
|
|
ko.dataFor = function(node) {
|
|
var context = ko.contextFor(node);
|
|
return context ? context['$data'] : undefined;
|
|
};
|
|
|
|
ko.exportSymbol('bindingHandlers', ko.bindingHandlers);
|
|
ko.exportSymbol('applyBindings', ko.applyBindings);
|
|
ko.exportSymbol('applyBindingsToDescendants', ko.applyBindingsToDescendants);
|
|
ko.exportSymbol('applyBindingAccessorsToNode', ko.applyBindingAccessorsToNode);
|
|
ko.exportSymbol('applyBindingsToNode', ko.applyBindingsToNode);
|
|
ko.exportSymbol('contextFor', ko.contextFor);
|
|
ko.exportSymbol('dataFor', ko.dataFor);
|
|
})();
|
|
(function(undefined) {
|
|
var loadingSubscribablesCache = {}, // Tracks component loads that are currently in flight
|
|
loadedDefinitionsCache = {}; // Tracks component loads that have already completed
|
|
|
|
ko.components = {
|
|
get: function(componentName, callback) {
|
|
var cachedDefinition = getObjectOwnProperty(loadedDefinitionsCache, componentName);
|
|
if (cachedDefinition) {
|
|
// It's already loaded and cached. Reuse the same definition object.
|
|
// Note that for API consistency, even cache hits complete asynchronously by default.
|
|
// You can bypass this by putting synchronous:true on your component config.
|
|
if (cachedDefinition.isSynchronousComponent) {
|
|
ko.dependencyDetection.ignore(function() { // See comment in loaderRegistryBehaviors.js for reasoning
|
|
callback(cachedDefinition.definition);
|
|
});
|
|
} else {
|
|
setTimeout(function() { callback(cachedDefinition.definition); }, 0);
|
|
}
|
|
} else {
|
|
// Join the loading process that is already underway, or start a new one.
|
|
loadComponentAndNotify(componentName, callback);
|
|
}
|
|
},
|
|
|
|
clearCachedDefinition: function(componentName) {
|
|
delete loadedDefinitionsCache[componentName];
|
|
},
|
|
|
|
_getFirstResultFromLoaders: getFirstResultFromLoaders
|
|
};
|
|
|
|
function getObjectOwnProperty(obj, propName) {
|
|
return obj.hasOwnProperty(propName) ? obj[propName] : undefined;
|
|
}
|
|
|
|
function loadComponentAndNotify(componentName, callback) {
|
|
var subscribable = getObjectOwnProperty(loadingSubscribablesCache, componentName),
|
|
completedAsync;
|
|
if (!subscribable) {
|
|
// It's not started loading yet. Start loading, and when it's done, move it to loadedDefinitionsCache.
|
|
subscribable = loadingSubscribablesCache[componentName] = new ko.subscribable();
|
|
subscribable.subscribe(callback);
|
|
|
|
beginLoadingComponent(componentName, function(definition, config) {
|
|
var isSynchronousComponent = !!(config && config['synchronous']);
|
|
loadedDefinitionsCache[componentName] = { definition: definition, isSynchronousComponent: isSynchronousComponent };
|
|
delete loadingSubscribablesCache[componentName];
|
|
|
|
// For API consistency, all loads complete asynchronously. However we want to avoid
|
|
// adding an extra setTimeout if it's unnecessary (i.e., the completion is already
|
|
// async) since setTimeout(..., 0) still takes about 16ms or more on most browsers.
|
|
//
|
|
// You can bypass the 'always synchronous' feature by putting the synchronous:true
|
|
// flag on your component configuration when you register it.
|
|
if (completedAsync || isSynchronousComponent) {
|
|
// Note that notifySubscribers ignores any dependencies read within the callback.
|
|
// See comment in loaderRegistryBehaviors.js for reasoning
|
|
subscribable['notifySubscribers'](definition);
|
|
} else {
|
|
setTimeout(function() {
|
|
subscribable['notifySubscribers'](definition);
|
|
}, 0);
|
|
}
|
|
});
|
|
completedAsync = true;
|
|
} else {
|
|
subscribable.subscribe(callback);
|
|
}
|
|
}
|
|
|
|
function beginLoadingComponent(componentName, callback) {
|
|
getFirstResultFromLoaders('getConfig', [componentName], function(config) {
|
|
if (config) {
|
|
// We have a config, so now load its definition
|
|
getFirstResultFromLoaders('loadComponent', [componentName, config], function(definition) {
|
|
callback(definition, config);
|
|
});
|
|
} else {
|
|
// The component has no config - it's unknown to all the loaders.
|
|
// Note that this is not an error (e.g., a module loading error) - that would abort the
|
|
// process and this callback would not run. For this callback to run, all loaders must
|
|
// have confirmed they don't know about this component.
|
|
callback(null, null);
|
|
}
|
|
});
|
|
}
|
|
|
|
function getFirstResultFromLoaders(methodName, argsExceptCallback, callback, candidateLoaders) {
|
|
// On the first call in the stack, start with the full set of loaders
|
|
if (!candidateLoaders) {
|
|
candidateLoaders = ko.components['loaders'].slice(0); // Use a copy, because we'll be mutating this array
|
|
}
|
|
|
|
// Try the next candidate
|
|
var currentCandidateLoader = candidateLoaders.shift();
|
|
if (currentCandidateLoader) {
|
|
var methodInstance = currentCandidateLoader[methodName];
|
|
if (methodInstance) {
|
|
var wasAborted = false,
|
|
synchronousReturnValue = methodInstance.apply(currentCandidateLoader, argsExceptCallback.concat(function(result) {
|
|
if (wasAborted) {
|
|
callback(null);
|
|
} else if (result !== null) {
|
|
// This candidate returned a value. Use it.
|
|
callback(result);
|
|
} else {
|
|
// Try the next candidate
|
|
getFirstResultFromLoaders(methodName, argsExceptCallback, callback, candidateLoaders);
|
|
}
|
|
}));
|
|
|
|
// Currently, loaders may not return anything synchronously. This leaves open the possibility
|
|
// that we'll extend the API to support synchronous return values in the future. It won't be
|
|
// a breaking change, because currently no loader is allowed to return anything except undefined.
|
|
if (synchronousReturnValue !== undefined) {
|
|
wasAborted = true;
|
|
|
|
// Method to suppress exceptions will remain undocumented. This is only to keep
|
|
// KO's specs running tidily, since we can observe the loading got aborted without
|
|
// having exceptions cluttering up the console too.
|
|
if (!currentCandidateLoader['suppressLoaderExceptions']) {
|
|
throw new Error('Component loaders must supply values by invoking the callback, not by returning values synchronously.');
|
|
}
|
|
}
|
|
} else {
|
|
// This candidate doesn't have the relevant handler. Synchronously move on to the next one.
|
|
getFirstResultFromLoaders(methodName, argsExceptCallback, callback, candidateLoaders);
|
|
}
|
|
} else {
|
|
// No candidates returned a value
|
|
callback(null);
|
|
}
|
|
}
|
|
|
|
// Reference the loaders via string name so it's possible for developers
|
|
// to replace the whole array by assigning to ko.components.loaders
|
|
ko.components['loaders'] = [];
|
|
|
|
ko.exportSymbol('components', ko.components);
|
|
ko.exportSymbol('components.get', ko.components.get);
|
|
ko.exportSymbol('components.clearCachedDefinition', ko.components.clearCachedDefinition);
|
|
})();
|
|
(function(undefined) {
|
|
|
|
// The default loader is responsible for two things:
|
|
// 1. Maintaining the default in-memory registry of component configuration objects
|
|
// (i.e., the thing you're writing to when you call ko.components.register(someName, ...))
|
|
// 2. Answering requests for components by fetching configuration objects
|
|
// from that default in-memory registry and resolving them into standard
|
|
// component definition objects (of the form { createViewModel: ..., template: ... })
|
|
// Custom loaders may override either of these facilities, i.e.,
|
|
// 1. To supply configuration objects from some other source (e.g., conventions)
|
|
// 2. Or, to resolve configuration objects by loading viewmodels/templates via arbitrary logic.
|
|
|
|
var defaultConfigRegistry = {};
|
|
|
|
ko.components.register = function(componentName, config) {
|
|
if (!config) {
|
|
throw new Error('Invalid configuration for ' + componentName);
|
|
}
|
|
|
|
if (ko.components.isRegistered(componentName)) {
|
|
throw new Error('Component ' + componentName + ' is already registered');
|
|
}
|
|
|
|
defaultConfigRegistry[componentName] = config;
|
|
}
|
|
|
|
ko.components.isRegistered = function(componentName) {
|
|
return componentName in defaultConfigRegistry;
|
|
}
|
|
|
|
ko.components.unregister = function(componentName) {
|
|
delete defaultConfigRegistry[componentName];
|
|
ko.components.clearCachedDefinition(componentName);
|
|
}
|
|
|
|
ko.components.defaultLoader = {
|
|
'getConfig': function(componentName, callback) {
|
|
var result = defaultConfigRegistry.hasOwnProperty(componentName)
|
|
? defaultConfigRegistry[componentName]
|
|
: null;
|
|
callback(result);
|
|
},
|
|
|
|
'loadComponent': function(componentName, config, callback) {
|
|
var errorCallback = makeErrorCallback(componentName);
|
|
possiblyGetConfigFromAmd(errorCallback, config, function(loadedConfig) {
|
|
resolveConfig(componentName, errorCallback, loadedConfig, callback);
|
|
});
|
|
},
|
|
|
|
'loadTemplate': function(componentName, templateConfig, callback) {
|
|
resolveTemplate(makeErrorCallback(componentName), templateConfig, callback);
|
|
},
|
|
|
|
'loadViewModel': function(componentName, viewModelConfig, callback) {
|
|
resolveViewModel(makeErrorCallback(componentName), viewModelConfig, callback);
|
|
}
|
|
};
|
|
|
|
var createViewModelKey = 'createViewModel';
|
|
|
|
// Takes a config object of the form { template: ..., viewModel: ... }, and asynchronously convert it
|
|
// into the standard component definition format:
|
|
// { template: <ArrayOfDomNodes>, createViewModel: function(params, componentInfo) { ... } }.
|
|
// Since both template and viewModel may need to be resolved asynchronously, both tasks are performed
|
|
// in parallel, and the results joined when both are ready. We don't depend on any promises infrastructure,
|
|
// so this is implemented manually below.
|
|
function resolveConfig(componentName, errorCallback, config, callback) {
|
|
var result = {},
|
|
makeCallBackWhenZero = 2,
|
|
tryIssueCallback = function() {
|
|
if (--makeCallBackWhenZero === 0) {
|
|
callback(result);
|
|
}
|
|
},
|
|
templateConfig = config['template'],
|
|
viewModelConfig = config['viewModel'];
|
|
|
|
if (templateConfig) {
|
|
possiblyGetConfigFromAmd(errorCallback, templateConfig, function(loadedConfig) {
|
|
ko.components._getFirstResultFromLoaders('loadTemplate', [componentName, loadedConfig], function(resolvedTemplate) {
|
|
result['template'] = resolvedTemplate;
|
|
tryIssueCallback();
|
|
});
|
|
});
|
|
} else {
|
|
tryIssueCallback();
|
|
}
|
|
|
|
if (viewModelConfig) {
|
|
possiblyGetConfigFromAmd(errorCallback, viewModelConfig, function(loadedConfig) {
|
|
ko.components._getFirstResultFromLoaders('loadViewModel', [componentName, loadedConfig], function(resolvedViewModel) {
|
|
result[createViewModelKey] = resolvedViewModel;
|
|
tryIssueCallback();
|
|
});
|
|
});
|
|
} else {
|
|
tryIssueCallback();
|
|
}
|
|
}
|
|
|
|
function resolveTemplate(errorCallback, templateConfig, callback) {
|
|
if (typeof templateConfig === 'string') {
|
|
// Markup - parse it
|
|
callback(ko.utils.parseHtmlFragment(templateConfig));
|
|
} else if (templateConfig instanceof Array) {
|
|
// Assume already an array of DOM nodes - pass through unchanged
|
|
callback(templateConfig);
|
|
} else if (isDocumentFragment(templateConfig)) {
|
|
// Document fragment - use its child nodes
|
|
callback(ko.utils.makeArray(templateConfig.childNodes));
|
|
} else if (templateConfig['element']) {
|
|
var element = templateConfig['element'];
|
|
if (isDomElement(element)) {
|
|
// Element instance - copy its child nodes
|
|
callback(cloneNodesFromTemplateSourceElement(element));
|
|
} else if (typeof element === 'string') {
|
|
// Element ID - find it, then copy its child nodes
|
|
var elemInstance = document.getElementById(element);
|
|
if (elemInstance) {
|
|
callback(cloneNodesFromTemplateSourceElement(elemInstance));
|
|
} else {
|
|
errorCallback('Cannot find element with ID ' + element);
|
|
}
|
|
} else {
|
|
errorCallback('Unknown element type: ' + element);
|
|
}
|
|
} else {
|
|
errorCallback('Unknown template value: ' + templateConfig);
|
|
}
|
|
}
|
|
|
|
function resolveViewModel(errorCallback, viewModelConfig, callback) {
|
|
if (typeof viewModelConfig === 'function') {
|
|
// Constructor - convert to standard factory function format
|
|
// By design, this does *not* supply componentInfo to the constructor, as the intent is that
|
|
// componentInfo contains non-viewmodel data (e.g., the component's element) that should only
|
|
// be used in factory functions, not viewmodel constructors.
|
|
callback(function (params /*, componentInfo */) {
|
|
return new viewModelConfig(params);
|
|
});
|
|
} else if (typeof viewModelConfig[createViewModelKey] === 'function') {
|
|
// Already a factory function - use it as-is
|
|
callback(viewModelConfig[createViewModelKey]);
|
|
} else if ('instance' in viewModelConfig) {
|
|
// Fixed object instance - promote to createViewModel format for API consistency
|
|
var fixedInstance = viewModelConfig['instance'];
|
|
callback(function (params, componentInfo) {
|
|
return fixedInstance;
|
|
});
|
|
} else if ('viewModel' in viewModelConfig) {
|
|
// Resolved AMD module whose value is of the form { viewModel: ... }
|
|
resolveViewModel(errorCallback, viewModelConfig['viewModel'], callback);
|
|
} else {
|
|
errorCallback('Unknown viewModel value: ' + viewModelConfig);
|
|
}
|
|
}
|
|
|
|
function cloneNodesFromTemplateSourceElement(elemInstance) {
|
|
switch (ko.utils.tagNameLower(elemInstance)) {
|
|
case 'script':
|
|
return ko.utils.parseHtmlFragment(elemInstance.text);
|
|
case 'textarea':
|
|
return ko.utils.parseHtmlFragment(elemInstance.value);
|
|
case 'template':
|
|
// For browsers with proper <template> element support (i.e., where the .content property
|
|
// gives a document fragment), use that document fragment.
|
|
if (isDocumentFragment(elemInstance.content)) {
|
|
return ko.utils.cloneNodes(elemInstance.content.childNodes);
|
|
}
|
|
}
|
|
|
|
// Regular elements such as <div>, and <template> elements on old browsers that don't really
|
|
// understand <template> and just treat it as a regular container
|
|
return ko.utils.cloneNodes(elemInstance.childNodes);
|
|
}
|
|
|
|
function isDomElement(obj) {
|
|
if (window['HTMLElement']) {
|
|
return obj instanceof HTMLElement;
|
|
} else {
|
|
return obj && obj.tagName && obj.nodeType === 1;
|
|
}
|
|
}
|
|
|
|
function isDocumentFragment(obj) {
|
|
if (window['DocumentFragment']) {
|
|
return obj instanceof DocumentFragment;
|
|
} else {
|
|
return obj && obj.nodeType === 11;
|
|
}
|
|
}
|
|
|
|
function possiblyGetConfigFromAmd(errorCallback, config, callback) {
|
|
if (typeof config['require'] === 'string') {
|
|
// The config is the value of an AMD module
|
|
if (amdRequire || window['require']) {
|
|
(amdRequire || window['require'])([config['require']], callback);
|
|
} else {
|
|
errorCallback('Uses require, but no AMD loader is present');
|
|
}
|
|
} else {
|
|
callback(config);
|
|
}
|
|
}
|
|
|
|
function makeErrorCallback(componentName) {
|
|
return function (message) {
|
|
throw new Error('Component \'' + componentName + '\': ' + message);
|
|
};
|
|
}
|
|
|
|
ko.exportSymbol('components.register', ko.components.register);
|
|
ko.exportSymbol('components.isRegistered', ko.components.isRegistered);
|
|
ko.exportSymbol('components.unregister', ko.components.unregister);
|
|
|
|
// Expose the default loader so that developers can directly ask it for configuration
|
|
// or to resolve configuration
|
|
ko.exportSymbol('components.defaultLoader', ko.components.defaultLoader);
|
|
|
|
// By default, the default loader is the only registered component loader
|
|
ko.components['loaders'].push(ko.components.defaultLoader);
|
|
|
|
// Privately expose the underlying config registry for use in old-IE shim
|
|
ko.components._allRegisteredComponents = defaultConfigRegistry;
|
|
})();
|
|
(function (undefined) {
|
|
// Overridable API for determining which component name applies to a given node. By overriding this,
|
|
// you can for example map specific tagNames to components that are not preregistered.
|
|
ko.components['getComponentNameForNode'] = function(node) {
|
|
var tagNameLower = ko.utils.tagNameLower(node);
|
|
return ko.components.isRegistered(tagNameLower) && tagNameLower;
|
|
};
|
|
|
|
ko.components.addBindingsForCustomElement = function(allBindings, node, bindingContext, valueAccessors) {
|
|
// Determine if it's really a custom element matching a component
|
|
if (node.nodeType === 1) {
|
|
var componentName = ko.components['getComponentNameForNode'](node);
|
|
if (componentName) {
|
|
// It does represent a component, so add a component binding for it
|
|
allBindings = allBindings || {};
|
|
|
|
if (allBindings['component']) {
|
|
// Avoid silently overwriting some other 'component' binding that may already be on the element
|
|
throw new Error('Cannot use the "component" binding on a custom element matching a component');
|
|
}
|
|
|
|
var componentBindingValue = { 'name': componentName, 'params': getComponentParamsFromCustomElement(node, bindingContext) };
|
|
|
|
allBindings['component'] = valueAccessors
|
|
? function() { return componentBindingValue; }
|
|
: componentBindingValue;
|
|
}
|
|
}
|
|
|
|
return allBindings;
|
|
}
|
|
|
|
var nativeBindingProviderInstance = new ko.bindingProvider();
|
|
|
|
function getComponentParamsFromCustomElement(elem, bindingContext) {
|
|
var paramsAttribute = elem.getAttribute('params');
|
|
|
|
if (paramsAttribute) {
|
|
var params = nativeBindingProviderInstance['parseBindingsString'](paramsAttribute, bindingContext, elem, { 'valueAccessors': true, 'bindingParams': true }),
|
|
rawParamComputedValues = ko.utils.objectMap(params, function(paramValue, paramName) {
|
|
return ko.computed(paramValue, null, { disposeWhenNodeIsRemoved: elem });
|
|
}),
|
|
result = ko.utils.objectMap(rawParamComputedValues, function(paramValueComputed, paramName) {
|
|
var paramValue = paramValueComputed.peek();
|
|
// Does the evaluation of the parameter value unwrap any observables?
|
|
if (!paramValueComputed.isActive()) {
|
|
// No it doesn't, so there's no need for any computed wrapper. Just pass through the supplied value directly.
|
|
// Example: "someVal: firstName, age: 123" (whether or not firstName is an observable/computed)
|
|
return paramValue;
|
|
} else {
|
|
// Yes it does. Supply a computed property that unwraps both the outer (binding expression)
|
|
// level of observability, and any inner (resulting model value) level of observability.
|
|
// This means the component doesn't have to worry about multiple unwrapping. If the value is a
|
|
// writable observable, the computed will also be writable and pass the value on to the observable.
|
|
return ko.computed({
|
|
'read': function() {
|
|
return ko.utils.unwrapObservable(paramValueComputed());
|
|
},
|
|
'write': ko.isWriteableObservable(paramValue) && function(value) {
|
|
paramValueComputed()(value);
|
|
},
|
|
disposeWhenNodeIsRemoved: elem
|
|
});
|
|
}
|
|
});
|
|
|
|
// Give access to the raw computeds, as long as that wouldn't overwrite any custom param also called '$raw'
|
|
// This is in case the developer wants to react to outer (binding) observability separately from inner
|
|
// (model value) observability, or in case the model value observable has subobservables.
|
|
if (!result.hasOwnProperty('$raw')) {
|
|
result['$raw'] = rawParamComputedValues;
|
|
}
|
|
|
|
return result;
|
|
} else {
|
|
// For consistency, absence of a "params" attribute is treated the same as the presence of
|
|
// any empty one. Otherwise component viewmodels need special code to check whether or not
|
|
// 'params' or 'params.$raw' is null/undefined before reading subproperties, which is annoying.
|
|
return { '$raw': {} };
|
|
}
|
|
}
|
|
|
|
// --------------------------------------------------------------------------------
|
|
// Compatibility code for older (pre-HTML5) IE browsers
|
|
|
|
if (ko.utils.ieVersion < 9) {
|
|
// Whenever you preregister a component, enable it as a custom element in the current document
|
|
ko.components['register'] = (function(originalFunction) {
|
|
return function(componentName) {
|
|
document.createElement(componentName); // Allows IE<9 to parse markup containing the custom element
|
|
return originalFunction.apply(this, arguments);
|
|
}
|
|
})(ko.components['register']);
|
|
|
|
// Whenever you create a document fragment, enable all preregistered component names as custom elements
|
|
// This is needed to make innerShiv/jQuery HTML parsing correctly handle the custom elements
|
|
document.createDocumentFragment = (function(originalFunction) {
|
|
return function() {
|
|
var newDocFrag = originalFunction(),
|
|
allComponents = ko.components._allRegisteredComponents;
|
|
for (var componentName in allComponents) {
|
|
if (allComponents.hasOwnProperty(componentName)) {
|
|
newDocFrag.createElement(componentName);
|
|
}
|
|
}
|
|
return newDocFrag;
|
|
};
|
|
})(document.createDocumentFragment);
|
|
}
|
|
})();(function(undefined) {
|
|
|
|
var componentLoadingOperationUniqueId = 0;
|
|
|
|
ko.bindingHandlers['component'] = {
|
|
'init': function(element, valueAccessor, ignored1, ignored2, bindingContext) {
|
|
var currentViewModel,
|
|
currentLoadingOperationId,
|
|
disposeAssociatedComponentViewModel = function () {
|
|
var currentViewModelDispose = currentViewModel && currentViewModel['dispose'];
|
|
if (typeof currentViewModelDispose === 'function') {
|
|
currentViewModelDispose.call(currentViewModel);
|
|
}
|
|
|
|
// Any in-flight loading operation is no longer relevant, so make sure we ignore its completion
|
|
currentLoadingOperationId = null;
|
|
},
|
|
originalChildNodes = ko.utils.makeArray(ko.virtualElements.childNodes(element));
|
|
|
|
ko.utils.domNodeDisposal.addDisposeCallback(element, disposeAssociatedComponentViewModel);
|
|
|
|
ko.computed(function () {
|
|
var value = ko.utils.unwrapObservable(valueAccessor()),
|
|
componentName, componentParams;
|
|
|
|
if (typeof value === 'string') {
|
|
componentName = value;
|
|
} else {
|
|
componentName = ko.utils.unwrapObservable(value['name']);
|
|
componentParams = ko.utils.unwrapObservable(value['params']);
|
|
}
|
|
|
|
if (!componentName) {
|
|
throw new Error('No component name specified');
|
|
}
|
|
|
|
var loadingOperationId = currentLoadingOperationId = ++componentLoadingOperationUniqueId;
|
|
ko.components.get(componentName, function(componentDefinition) {
|
|
// If this is not the current load operation for this element, ignore it.
|
|
if (currentLoadingOperationId !== loadingOperationId) {
|
|
return;
|
|
}
|
|
|
|
// Clean up previous state
|
|
disposeAssociatedComponentViewModel();
|
|
|
|
// Instantiate and bind new component. Implicitly this cleans any old DOM nodes.
|
|
if (!componentDefinition) {
|
|
throw new Error('Unknown component \'' + componentName + '\'');
|
|
}
|
|
cloneTemplateIntoElement(componentName, componentDefinition, element);
|
|
var componentViewModel = createViewModel(componentDefinition, element, originalChildNodes, componentParams),
|
|
childBindingContext = bindingContext['createChildContext'](componentViewModel, /* dataItemAlias */ undefined, function(ctx) {
|
|
ctx['$component'] = componentViewModel;
|
|
ctx['$componentTemplateNodes'] = originalChildNodes;
|
|
});
|
|
currentViewModel = componentViewModel;
|
|
ko.applyBindingsToDescendants(childBindingContext, element);
|
|
});
|
|
}, null, { disposeWhenNodeIsRemoved: element });
|
|
|
|
return { 'controlsDescendantBindings': true };
|
|
}
|
|
};
|
|
|
|
ko.virtualElements.allowedBindings['component'] = true;
|
|
|
|
function cloneTemplateIntoElement(componentName, componentDefinition, element) {
|
|
var template = componentDefinition['template'];
|
|
if (!template) {
|
|
throw new Error('Component \'' + componentName + '\' has no template');
|
|
}
|
|
|
|
var clonedNodesArray = ko.utils.cloneNodes(template);
|
|
ko.virtualElements.setDomNodeChildren(element, clonedNodesArray);
|
|
}
|
|
|
|
function createViewModel(componentDefinition, element, originalChildNodes, componentParams) {
|
|
var componentViewModelFactory = componentDefinition['createViewModel'];
|
|
return componentViewModelFactory
|
|
? componentViewModelFactory.call(componentDefinition, componentParams, { 'element': element, 'templateNodes': originalChildNodes })
|
|
: componentParams; // Template-only component
|
|
}
|
|
|
|
})();
|
|
var attrHtmlToJavascriptMap = { 'class': 'className', 'for': 'htmlFor' };
|
|
ko.bindingHandlers['attr'] = {
|
|
'update': function(element, valueAccessor, allBindings) {
|
|
var value = ko.utils.unwrapObservable(valueAccessor()) || {};
|
|
ko.utils.objectForEach(value, function(attrName, attrValue) {
|
|
attrValue = ko.utils.unwrapObservable(attrValue);
|
|
|
|
// To cover cases like "attr: { checked:someProp }", we want to remove the attribute entirely
|
|
// when someProp is a "no value"-like value (strictly null, false, or undefined)
|
|
// (because the absence of the "checked" attr is how to mark an element as not checked, etc.)
|
|
var toRemove = (attrValue === false) || (attrValue === null) || (attrValue === undefined);
|
|
if (toRemove)
|
|
element.removeAttribute(attrName);
|
|
|
|
// In IE <= 7 and IE8 Quirks Mode, you have to use the Javascript property name instead of the
|
|
// HTML attribute name for certain attributes. IE8 Standards Mode supports the correct behavior,
|
|
// but instead of figuring out the mode, we'll just set the attribute through the Javascript
|
|
// property for IE <= 8.
|
|
if (ko.utils.ieVersion <= 8 && attrName in attrHtmlToJavascriptMap) {
|
|
attrName = attrHtmlToJavascriptMap[attrName];
|
|
if (toRemove)
|
|
element.removeAttribute(attrName);
|
|
else
|
|
element[attrName] = attrValue;
|
|
} else if (!toRemove) {
|
|
element.setAttribute(attrName, attrValue.toString());
|
|
}
|
|
|
|
// Treat "name" specially - although you can think of it as an attribute, it also needs
|
|
// special handling on older versions of IE (https://github.com/SteveSanderson/knockout/pull/333)
|
|
// Deliberately being case-sensitive here because XHTML would regard "Name" as a different thing
|
|
// entirely, and there's no strong reason to allow for such casing in HTML.
|
|
if (attrName === "name") {
|
|
ko.utils.setElementName(element, toRemove ? "" : attrValue.toString());
|
|
}
|
|
});
|
|
}
|
|
};
|
|
(function() {
|
|
|
|
ko.bindingHandlers['checked'] = {
|
|
'after': ['value', 'attr'],
|
|
'init': function (element, valueAccessor, allBindings) {
|
|
var checkedValue = ko.pureComputed(function() {
|
|
// Treat "value" like "checkedValue" when it is included with "checked" binding
|
|
if (allBindings['has']('checkedValue')) {
|
|
return ko.utils.unwrapObservable(allBindings.get('checkedValue'));
|
|
} else if (allBindings['has']('value')) {
|
|
return ko.utils.unwrapObservable(allBindings.get('value'));
|
|
}
|
|
|
|
return element.value;
|
|
});
|
|
|
|
function updateModel() {
|
|
// This updates the model value from the view value.
|
|
// It runs in response to DOM events (click) and changes in checkedValue.
|
|
var isChecked = element.checked,
|
|
elemValue = useCheckedValue ? checkedValue() : isChecked;
|
|
|
|
// When we're first setting up this computed, don't change any model state.
|
|
if (ko.computedContext.isInitial()) {
|
|
return;
|
|
}
|
|
|
|
// We can ignore unchecked radio buttons, because some other radio
|
|
// button will be getting checked, and that one can take care of updating state.
|
|
if (isRadio && !isChecked) {
|
|
return;
|
|
}
|
|
|
|
var modelValue = ko.dependencyDetection.ignore(valueAccessor);
|
|
if (isValueArray) {
|
|
if (oldElemValue !== elemValue) {
|
|
// When we're responding to the checkedValue changing, and the element is
|
|
// currently checked, replace the old elem value with the new elem value
|
|
// in the model array.
|
|
if (isChecked) {
|
|
ko.utils.addOrRemoveItem(modelValue, elemValue, true);
|
|
ko.utils.addOrRemoveItem(modelValue, oldElemValue, false);
|
|
}
|
|
|
|
oldElemValue = elemValue;
|
|
} else {
|
|
// When we're responding to the user having checked/unchecked a checkbox,
|
|
// add/remove the element value to the model array.
|
|
ko.utils.addOrRemoveItem(modelValue, elemValue, isChecked);
|
|
}
|
|
} else {
|
|
ko.expressionRewriting.writeValueToProperty(modelValue, allBindings, 'checked', elemValue, true);
|
|
}
|
|
};
|
|
|
|
function updateView() {
|
|
// This updates the view value from the model value.
|
|
// It runs in response to changes in the bound (checked) value.
|
|
var modelValue = ko.utils.unwrapObservable(valueAccessor());
|
|
|
|
if (isValueArray) {
|
|
// When a checkbox is bound to an array, being checked represents its value being present in that array
|
|
element.checked = ko.utils.arrayIndexOf(modelValue, checkedValue()) >= 0;
|
|
} else if (isCheckbox) {
|
|
// When a checkbox is bound to any other value (not an array), being checked represents the value being trueish
|
|
element.checked = modelValue;
|
|
} else {
|
|
// For radio buttons, being checked means that the radio button's value corresponds to the model value
|
|
element.checked = (checkedValue() === modelValue);
|
|
}
|
|
};
|
|
|
|
var isCheckbox = element.type == "checkbox",
|
|
isRadio = element.type == "radio";
|
|
|
|
// Only bind to check boxes and radio buttons
|
|
if (!isCheckbox && !isRadio) {
|
|
return;
|
|
}
|
|
|
|
var isValueArray = isCheckbox && (ko.utils.unwrapObservable(valueAccessor()) instanceof Array),
|
|
oldElemValue = isValueArray ? checkedValue() : undefined,
|
|
useCheckedValue = isRadio || isValueArray;
|
|
|
|
// IE 6 won't allow radio buttons to be selected unless they have a name
|
|
if (isRadio && !element.name)
|
|
ko.bindingHandlers['uniqueName']['init'](element, function() { return true });
|
|
|
|
// Set up two computeds to update the binding:
|
|
|
|
// The first responds to changes in the checkedValue value and to element clicks
|
|
ko.computed(updateModel, null, { disposeWhenNodeIsRemoved: element });
|
|
ko.utils.registerEventHandler(element, "click", updateModel);
|
|
|
|
// The second responds to changes in the model value (the one associated with the checked binding)
|
|
ko.computed(updateView, null, { disposeWhenNodeIsRemoved: element });
|
|
}
|
|
};
|
|
ko.expressionRewriting.twoWayBindings['checked'] = true;
|
|
|
|
ko.bindingHandlers['checkedValue'] = {
|
|
'update': function (element, valueAccessor) {
|
|
element.value = ko.utils.unwrapObservable(valueAccessor());
|
|
}
|
|
};
|
|
|
|
})();var classesWrittenByBindingKey = '__ko__cssValue';
|
|
ko.bindingHandlers['css'] = {
|
|
'update': function (element, valueAccessor) {
|
|
var value = ko.utils.unwrapObservable(valueAccessor());
|
|
if (value !== null && typeof value == "object") {
|
|
ko.utils.objectForEach(value, function(className, shouldHaveClass) {
|
|
shouldHaveClass = ko.utils.unwrapObservable(shouldHaveClass);
|
|
ko.utils.toggleDomNodeCssClass(element, className, shouldHaveClass);
|
|
});
|
|
} else {
|
|
value = String(value || ''); // Make sure we don't try to store or set a non-string value
|
|
ko.utils.toggleDomNodeCssClass(element, element[classesWrittenByBindingKey], false);
|
|
element[classesWrittenByBindingKey] = value;
|
|
ko.utils.toggleDomNodeCssClass(element, value, true);
|
|
}
|
|
}
|
|
};
|
|
ko.bindingHandlers['enable'] = {
|
|
'update': function (element, valueAccessor) {
|
|
var value = ko.utils.unwrapObservable(valueAccessor());
|
|
if (value && element.disabled)
|
|
element.removeAttribute("disabled");
|
|
else if ((!value) && (!element.disabled))
|
|
element.disabled = true;
|
|
}
|
|
};
|
|
|
|
ko.bindingHandlers['disable'] = {
|
|
'update': function (element, valueAccessor) {
|
|
ko.bindingHandlers['enable']['update'](element, function() { return !ko.utils.unwrapObservable(valueAccessor()) });
|
|
}
|
|
};
|
|
// For certain common events (currently just 'click'), allow a simplified data-binding syntax
|
|
// e.g. click:handler instead of the usual full-length event:{click:handler}
|
|
function makeEventHandlerShortcut(eventName) {
|
|
ko.bindingHandlers[eventName] = {
|
|
'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
|
|
var newValueAccessor = function () {
|
|
var result = {};
|
|
result[eventName] = valueAccessor();
|
|
return result;
|
|
};
|
|
return ko.bindingHandlers['event']['init'].call(this, element, newValueAccessor, allBindings, viewModel, bindingContext);
|
|
}
|
|
}
|
|
}
|
|
|
|
ko.bindingHandlers['event'] = {
|
|
'init' : function (element, valueAccessor, allBindings, viewModel, bindingContext) {
|
|
var eventsToHandle = valueAccessor() || {};
|
|
ko.utils.objectForEach(eventsToHandle, function(eventName) {
|
|
if (typeof eventName == "string") {
|
|
ko.utils.registerEventHandler(element, eventName, function (event) {
|
|
var handlerReturnValue;
|
|
var handlerFunction = valueAccessor()[eventName];
|
|
if (!handlerFunction)
|
|
return;
|
|
|
|
try {
|
|
// Take all the event args, and prefix with the viewmodel
|
|
var argsForHandler = ko.utils.makeArray(arguments);
|
|
viewModel = bindingContext['$data'];
|
|
argsForHandler.unshift(viewModel);
|
|
handlerReturnValue = handlerFunction.apply(viewModel, argsForHandler);
|
|
} finally {
|
|
if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.
|
|
if (event.preventDefault)
|
|
event.preventDefault();
|
|
else
|
|
event.returnValue = false;
|
|
}
|
|
}
|
|
|
|
var bubble = allBindings.get(eventName + 'Bubble') !== false;
|
|
if (!bubble) {
|
|
event.cancelBubble = true;
|
|
if (event.stopPropagation)
|
|
event.stopPropagation();
|
|
}
|
|
});
|
|
}
|
|
});
|
|
}
|
|
};
|
|
// "foreach: someExpression" is equivalent to "template: { foreach: someExpression }"
|
|
// "foreach: { data: someExpression, afterAdd: myfn }" is equivalent to "template: { foreach: someExpression, afterAdd: myfn }"
|
|
ko.bindingHandlers['foreach'] = {
|
|
makeTemplateValueAccessor: function(valueAccessor) {
|
|
return function() {
|
|
var modelValue = valueAccessor(),
|
|
unwrappedValue = ko.utils.peekObservable(modelValue); // Unwrap without setting a dependency here
|
|
|
|
// If unwrappedValue is the array, pass in the wrapped value on its own
|
|
// The value will be unwrapped and tracked within the template binding
|
|
// (See https://github.com/SteveSanderson/knockout/issues/523)
|
|
if ((!unwrappedValue) || typeof unwrappedValue.length == "number")
|
|
return { 'foreach': modelValue, 'templateEngine': ko.nativeTemplateEngine.instance };
|
|
|
|
// If unwrappedValue.data is the array, preserve all relevant options and unwrap again value so we get updates
|
|
ko.utils.unwrapObservable(modelValue);
|
|
return {
|
|
'foreach': unwrappedValue['data'],
|
|
'as': unwrappedValue['as'],
|
|
'includeDestroyed': unwrappedValue['includeDestroyed'],
|
|
'afterAdd': unwrappedValue['afterAdd'],
|
|
'beforeRemove': unwrappedValue['beforeRemove'],
|
|
'afterRender': unwrappedValue['afterRender'],
|
|
'beforeMove': unwrappedValue['beforeMove'],
|
|
'afterMove': unwrappedValue['afterMove'],
|
|
'templateEngine': ko.nativeTemplateEngine.instance
|
|
};
|
|
};
|
|
},
|
|
'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
|
|
return ko.bindingHandlers['template']['init'](element, ko.bindingHandlers['foreach'].makeTemplateValueAccessor(valueAccessor));
|
|
},
|
|
'update': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
|
|
return ko.bindingHandlers['template']['update'](element, ko.bindingHandlers['foreach'].makeTemplateValueAccessor(valueAccessor), allBindings, viewModel, bindingContext);
|
|
}
|
|
};
|
|
ko.expressionRewriting.bindingRewriteValidators['foreach'] = false; // Can't rewrite control flow bindings
|
|
ko.virtualElements.allowedBindings['foreach'] = true;
|
|
var hasfocusUpdatingProperty = '__ko_hasfocusUpdating';
|
|
var hasfocusLastValue = '__ko_hasfocusLastValue';
|
|
ko.bindingHandlers['hasfocus'] = {
|
|
'init': function(element, valueAccessor, allBindings) {
|
|
var handleElementFocusChange = function(isFocused) {
|
|
// Where possible, ignore which event was raised and determine focus state using activeElement,
|
|
// as this avoids phantom focus/blur events raised when changing tabs in modern browsers.
|
|
// However, not all KO-targeted browsers (Firefox 2) support activeElement. For those browsers,
|
|
// prevent a loss of focus when changing tabs/windows by setting a flag that prevents hasfocus
|
|
// from calling 'blur()' on the element when it loses focus.
|
|
// Discussion at https://github.com/SteveSanderson/knockout/pull/352
|
|
element[hasfocusUpdatingProperty] = true;
|
|
var ownerDoc = element.ownerDocument;
|
|
if ("activeElement" in ownerDoc) {
|
|
var active;
|
|
try {
|
|
active = ownerDoc.activeElement;
|
|
} catch(e) {
|
|
// IE9 throws if you access activeElement during page load (see issue #703)
|
|
active = ownerDoc.body;
|
|
}
|
|
isFocused = (active === element);
|
|
}
|
|
var modelValue = valueAccessor();
|
|
ko.expressionRewriting.writeValueToProperty(modelValue, allBindings, 'hasfocus', isFocused, true);
|
|
|
|
//cache the latest value, so we can avoid unnecessarily calling focus/blur in the update function
|
|
element[hasfocusLastValue] = isFocused;
|
|
element[hasfocusUpdatingProperty] = false;
|
|
};
|
|
var handleElementFocusIn = handleElementFocusChange.bind(null, true);
|
|
var handleElementFocusOut = handleElementFocusChange.bind(null, false);
|
|
|
|
ko.utils.registerEventHandler(element, "focus", handleElementFocusIn);
|
|
ko.utils.registerEventHandler(element, "focusin", handleElementFocusIn); // For IE
|
|
ko.utils.registerEventHandler(element, "blur", handleElementFocusOut);
|
|
ko.utils.registerEventHandler(element, "focusout", handleElementFocusOut); // For IE
|
|
},
|
|
'update': function(element, valueAccessor) {
|
|
var value = !!ko.utils.unwrapObservable(valueAccessor()); //force boolean to compare with last value
|
|
if (!element[hasfocusUpdatingProperty] && element[hasfocusLastValue] !== value) {
|
|
value ? element.focus() : element.blur();
|
|
ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, value ? "focusin" : "focusout"]); // For IE, which doesn't reliably fire "focus" or "blur" events synchronously
|
|
}
|
|
}
|
|
};
|
|
ko.expressionRewriting.twoWayBindings['hasfocus'] = true;
|
|
|
|
ko.bindingHandlers['hasFocus'] = ko.bindingHandlers['hasfocus']; // Make "hasFocus" an alias
|
|
ko.expressionRewriting.twoWayBindings['hasFocus'] = true;
|
|
ko.bindingHandlers['html'] = {
|
|
'init': function() {
|
|
// Prevent binding on the dynamically-injected HTML (as developers are unlikely to expect that, and it has security implications)
|
|
return { 'controlsDescendantBindings': true };
|
|
},
|
|
'update': function (element, valueAccessor) {
|
|
// setHtml will unwrap the value if needed
|
|
ko.utils.setHtml(element, valueAccessor());
|
|
}
|
|
};
|
|
// Makes a binding like with or if
|
|
function makeWithIfBinding(bindingKey, isWith, isNot, makeContextCallback) {
|
|
ko.bindingHandlers[bindingKey] = {
|
|
'init': function(element, valueAccessor, allBindings, viewModel, bindingContext) {
|
|
var didDisplayOnLastUpdate,
|
|
savedNodes;
|
|
ko.computed(function() {
|
|
var dataValue = ko.utils.unwrapObservable(valueAccessor()),
|
|
shouldDisplay = !isNot !== !dataValue, // equivalent to isNot ? !dataValue : !!dataValue
|
|
isFirstRender = !savedNodes,
|
|
needsRefresh = isFirstRender || isWith || (shouldDisplay !== didDisplayOnLastUpdate);
|
|
|
|
if (needsRefresh) {
|
|
// Save a copy of the inner nodes on the initial update, but only if we have dependencies.
|
|
if (isFirstRender && ko.computedContext.getDependenciesCount()) {
|
|
savedNodes = ko.utils.cloneNodes(ko.virtualElements.childNodes(element), true /* shouldCleanNodes */);
|
|
}
|
|
|
|
if (shouldDisplay) {
|
|
if (!isFirstRender) {
|
|
ko.virtualElements.setDomNodeChildren(element, ko.utils.cloneNodes(savedNodes));
|
|
}
|
|
ko.applyBindingsToDescendants(makeContextCallback ? makeContextCallback(bindingContext, dataValue) : bindingContext, element);
|
|
} else {
|
|
ko.virtualElements.emptyNode(element);
|
|
}
|
|
|
|
didDisplayOnLastUpdate = shouldDisplay;
|
|
}
|
|
}, null, { disposeWhenNodeIsRemoved: element });
|
|
return { 'controlsDescendantBindings': true };
|
|
}
|
|
};
|
|
ko.expressionRewriting.bindingRewriteValidators[bindingKey] = false; // Can't rewrite control flow bindings
|
|
ko.virtualElements.allowedBindings[bindingKey] = true;
|
|
}
|
|
|
|
// Construct the actual binding handlers
|
|
makeWithIfBinding('if');
|
|
makeWithIfBinding('ifnot', false /* isWith */, true /* isNot */);
|
|
makeWithIfBinding('with', true /* isWith */, false /* isNot */,
|
|
function(bindingContext, dataValue) {
|
|
return bindingContext['createChildContext'](dataValue);
|
|
}
|
|
);
|
|
var captionPlaceholder = {};
|
|
ko.bindingHandlers['options'] = {
|
|
'init': function(element) {
|
|
if (ko.utils.tagNameLower(element) !== "select")
|
|
throw new Error("options binding applies only to SELECT elements");
|
|
|
|
// Remove all existing <option>s.
|
|
while (element.length > 0) {
|
|
element.remove(0);
|
|
}
|
|
|
|
// Ensures that the binding processor doesn't try to bind the options
|
|
return { 'controlsDescendantBindings': true };
|
|
},
|
|
'update': function (element, valueAccessor, allBindings) {
|
|
function selectedOptions() {
|
|
return ko.utils.arrayFilter(element.options, function (node) { return node.selected; });
|
|
}
|
|
|
|
var selectWasPreviouslyEmpty = element.length == 0,
|
|
multiple = element.multiple,
|
|
previousScrollTop = (!selectWasPreviouslyEmpty && multiple) ? element.scrollTop : null,
|
|
unwrappedArray = ko.utils.unwrapObservable(valueAccessor()),
|
|
valueAllowUnset = allBindings.get('valueAllowUnset') && allBindings['has']('value'),
|
|
includeDestroyed = allBindings.get('optionsIncludeDestroyed'),
|
|
arrayToDomNodeChildrenOptions = {},
|
|
captionValue,
|
|
filteredArray,
|
|
previousSelectedValues = [];
|
|
|
|
if (!valueAllowUnset) {
|
|
if (multiple) {
|
|
previousSelectedValues = ko.utils.arrayMap(selectedOptions(), ko.selectExtensions.readValue);
|
|
} else if (element.selectedIndex >= 0) {
|
|
previousSelectedValues.push(ko.selectExtensions.readValue(element.options[element.selectedIndex]));
|
|
}
|
|
}
|
|
|
|
if (unwrappedArray) {
|
|
if (typeof unwrappedArray.length == "undefined") // Coerce single value into array
|
|
unwrappedArray = [unwrappedArray];
|
|
|
|
// Filter out any entries marked as destroyed
|
|
filteredArray = ko.utils.arrayFilter(unwrappedArray, function(item) {
|
|
return includeDestroyed || item === undefined || item === null || !ko.utils.unwrapObservable(item['_destroy']);
|
|
});
|
|
|
|
// If caption is included, add it to the array
|
|
if (allBindings['has']('optionsCaption')) {
|
|
captionValue = ko.utils.unwrapObservable(allBindings.get('optionsCaption'));
|
|
// If caption value is null or undefined, don't show a caption
|
|
if (captionValue !== null && captionValue !== undefined) {
|
|
filteredArray.unshift(captionPlaceholder);
|
|
}
|
|
}
|
|
} else {
|
|
// If a falsy value is provided (e.g. null), we'll simply empty the select element
|
|
}
|
|
|
|
function applyToObject(object, predicate, defaultValue) {
|
|
var predicateType = typeof predicate;
|
|
if (predicateType == "function") // Given a function; run it against the data value
|
|
return predicate(object);
|
|
else if (predicateType == "string") // Given a string; treat it as a property name on the data value
|
|
return object[predicate];
|
|
else // Given no optionsText arg; use the data value itself
|
|
return defaultValue;
|
|
}
|
|
|
|
// The following functions can run at two different times:
|
|
// The first is when the whole array is being updated directly from this binding handler.
|
|
// The second is when an observable value for a specific array entry is updated.
|
|
// oldOptions will be empty in the first case, but will be filled with the previously generated option in the second.
|
|
var itemUpdate = false;
|
|
function optionForArrayItem(arrayEntry, index, oldOptions) {
|
|
if (oldOptions.length) {
|
|
previousSelectedValues = !valueAllowUnset && oldOptions[0].selected ? [ ko.selectExtensions.readValue(oldOptions[0]) ] : [];
|
|
itemUpdate = true;
|
|
}
|
|
var option = element.ownerDocument.createElement("option");
|
|
if (arrayEntry === captionPlaceholder) {
|
|
ko.utils.setTextContent(option, allBindings.get('optionsCaption'));
|
|
ko.selectExtensions.writeValue(option, undefined);
|
|
} else {
|
|
// Apply a value to the option element
|
|
var optionValue = applyToObject(arrayEntry, allBindings.get('optionsValue'), arrayEntry);
|
|
ko.selectExtensions.writeValue(option, ko.utils.unwrapObservable(optionValue));
|
|
|
|
// Apply some text to the option element
|
|
var optionText = applyToObject(arrayEntry, allBindings.get('optionsText'), optionValue);
|
|
ko.utils.setTextContent(option, optionText);
|
|
}
|
|
return [option];
|
|
}
|
|
|
|
// By using a beforeRemove callback, we delay the removal until after new items are added. This fixes a selection
|
|
// problem in IE<=8 and Firefox. See https://github.com/knockout/knockout/issues/1208
|
|
arrayToDomNodeChildrenOptions['beforeRemove'] =
|
|
function (option) {
|
|
element.removeChild(option);
|
|
};
|
|
|
|
function setSelectionCallback(arrayEntry, newOptions) {
|
|
if (itemUpdate && valueAllowUnset) {
|
|
// The model value is authoritative, so make sure its value is the one selected
|
|
// There is no need to use dependencyDetection.ignore since setDomNodeChildrenFromArrayMapping does so already.
|
|
ko.selectExtensions.writeValue(element, ko.utils.unwrapObservable(allBindings.get('value')), true /* allowUnset */);
|
|
} else if (previousSelectedValues.length) {
|
|
// IE6 doesn't like us to assign selection to OPTION nodes before they're added to the document.
|
|
// That's why we first added them without selection. Now it's time to set the selection.
|
|
var isSelected = ko.utils.arrayIndexOf(previousSelectedValues, ko.selectExtensions.readValue(newOptions[0])) >= 0;
|
|
ko.utils.setOptionNodeSelectionState(newOptions[0], isSelected);
|
|
|
|
// If this option was changed from being selected during a single-item update, notify the change
|
|
if (itemUpdate && !isSelected) {
|
|
ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, "change"]);
|
|
}
|
|
}
|
|
}
|
|
|
|
var callback = setSelectionCallback;
|
|
if (allBindings['has']('optionsAfterRender') && typeof allBindings.get('optionsAfterRender') == "function") {
|
|
callback = function(arrayEntry, newOptions) {
|
|
setSelectionCallback(arrayEntry, newOptions);
|
|
ko.dependencyDetection.ignore(allBindings.get('optionsAfterRender'), null, [newOptions[0], arrayEntry !== captionPlaceholder ? arrayEntry : undefined]);
|
|
}
|
|
}
|
|
|
|
ko.utils.setDomNodeChildrenFromArrayMapping(element, filteredArray, optionForArrayItem, arrayToDomNodeChildrenOptions, callback);
|
|
|
|
ko.dependencyDetection.ignore(function () {
|
|
if (valueAllowUnset) {
|
|
// The model value is authoritative, so make sure its value is the one selected
|
|
ko.selectExtensions.writeValue(element, ko.utils.unwrapObservable(allBindings.get('value')), true /* allowUnset */);
|
|
} else {
|
|
// Determine if the selection has changed as a result of updating the options list
|
|
var selectionChanged;
|
|
if (multiple) {
|
|
// For a multiple-select box, compare the new selection count to the previous one
|
|
// But if nothing was selected before, the selection can't have changed
|
|
selectionChanged = previousSelectedValues.length && selectedOptions().length < previousSelectedValues.length;
|
|
} else {
|
|
// For a single-select box, compare the current value to the previous value
|
|
// But if nothing was selected before or nothing is selected now, just look for a change in selection
|
|
selectionChanged = (previousSelectedValues.length && element.selectedIndex >= 0)
|
|
? (ko.selectExtensions.readValue(element.options[element.selectedIndex]) !== previousSelectedValues[0])
|
|
: (previousSelectedValues.length || element.selectedIndex >= 0);
|
|
}
|
|
|
|
// Ensure consistency between model value and selected option.
|
|
// If the dropdown was changed so that selection is no longer the same,
|
|
// notify the value or selectedOptions binding.
|
|
if (selectionChanged) {
|
|
ko.utils.triggerEvent(element, "change");
|
|
}
|
|
}
|
|
});
|
|
|
|
// Workaround for IE bug
|
|
ko.utils.ensureSelectElementIsRenderedCorrectly(element);
|
|
|
|
if (previousScrollTop && Math.abs(previousScrollTop - element.scrollTop) > 20)
|
|
element.scrollTop = previousScrollTop;
|
|
}
|
|
};
|
|
ko.bindingHandlers['options'].optionValueDomDataKey = ko.utils.domData.nextKey();
|
|
ko.bindingHandlers['selectedOptions'] = {
|
|
'after': ['options', 'foreach'],
|
|
'init': function (element, valueAccessor, allBindings) {
|
|
ko.utils.registerEventHandler(element, "change", function () {
|
|
var value = valueAccessor(), valueToWrite = [];
|
|
ko.utils.arrayForEach(element.getElementsByTagName("option"), function(node) {
|
|
if (node.selected)
|
|
valueToWrite.push(ko.selectExtensions.readValue(node));
|
|
});
|
|
ko.expressionRewriting.writeValueToProperty(value, allBindings, 'selectedOptions', valueToWrite);
|
|
});
|
|
},
|
|
'update': function (element, valueAccessor) {
|
|
if (ko.utils.tagNameLower(element) != "select")
|
|
throw new Error("values binding applies only to SELECT elements");
|
|
|
|
var newValue = ko.utils.unwrapObservable(valueAccessor());
|
|
if (newValue && typeof newValue.length == "number") {
|
|
ko.utils.arrayForEach(element.getElementsByTagName("option"), function(node) {
|
|
var isSelected = ko.utils.arrayIndexOf(newValue, ko.selectExtensions.readValue(node)) >= 0;
|
|
ko.utils.setOptionNodeSelectionState(node, isSelected);
|
|
});
|
|
}
|
|
}
|
|
};
|
|
ko.expressionRewriting.twoWayBindings['selectedOptions'] = true;
|
|
ko.bindingHandlers['style'] = {
|
|
'update': function (element, valueAccessor) {
|
|
var value = ko.utils.unwrapObservable(valueAccessor() || {});
|
|
ko.utils.objectForEach(value, function(styleName, styleValue) {
|
|
styleValue = ko.utils.unwrapObservable(styleValue);
|
|
|
|
if (styleValue === null || styleValue === undefined || styleValue === false) {
|
|
// Empty string removes the value, whereas null/undefined have no effect
|
|
styleValue = "";
|
|
}
|
|
|
|
element.style[styleName] = styleValue;
|
|
});
|
|
}
|
|
};
|
|
ko.bindingHandlers['submit'] = {
|
|
'init': function (element, valueAccessor, allBindings, viewModel, bindingContext) {
|
|
if (typeof valueAccessor() != "function")
|
|
throw new Error("The value for a submit binding must be a function");
|
|
ko.utils.registerEventHandler(element, "submit", function (event) {
|
|
var handlerReturnValue;
|
|
var value = valueAccessor();
|
|
try { handlerReturnValue = value.call(bindingContext['$data'], element); }
|
|
finally {
|
|
if (handlerReturnValue !== true) { // Normally we want to prevent default action. Developer can override this be explicitly returning true.
|
|
if (event.preventDefault)
|
|
event.preventDefault();
|
|
else
|
|
event.returnValue = false;
|
|
}
|
|
}
|
|
});
|
|
}
|
|
};
|
|
ko.bindingHandlers['text'] = {
|
|
'init': function() {
|
|
// Prevent binding on the dynamically-injected text node (as developers are unlikely to expect that, and it has security implications).
|
|
// It should also make things faster, as we no longer have to consider whether the text node might be bindable.
|
|
return { 'controlsDescendantBindings': true };
|
|
},
|
|
'update': function (element, valueAccessor) {
|
|
ko.utils.setTextContent(element, valueAccessor());
|
|
}
|
|
};
|
|
ko.virtualElements.allowedBindings['text'] = true;
|
|
(function () {
|
|
|
|
if (window && window.navigator) {
|
|
var parseVersion = function (matches) {
|
|
if (matches) {
|
|
return parseFloat(matches[1]);
|
|
}
|
|
};
|
|
|
|
// Detect various browser versions because some old versions don't fully support the 'input' event
|
|
var operaVersion = window.opera && window.opera.version && parseInt(window.opera.version()),
|
|
userAgent = window.navigator.userAgent,
|
|
safariVersion = parseVersion(userAgent.match(/^(?:(?!chrome).)*version\/([^ ]*) safari/i)),
|
|
firefoxVersion = parseVersion(userAgent.match(/Firefox\/([^ ]*)/));
|
|
}
|
|
|
|
// IE 8 and 9 have bugs that prevent the normal events from firing when the value changes.
|
|
// But it does fire the 'selectionchange' event on many of those, presumably because the
|
|
// cursor is moving and that counts as the selection changing. The 'selectionchange' event is
|
|
// fired at the document level only and doesn't directly indicate which element changed. We
|
|
// set up just one event handler for the document and use 'activeElement' to determine which
|
|
// element was changed.
|
|
if (ko.utils.ieVersion < 10) {
|
|
var selectionChangeRegisteredName = ko.utils.domData.nextKey(),
|
|
selectionChangeHandlerName = ko.utils.domData.nextKey();
|
|
var selectionChangeHandler = function(event) {
|
|
var target = this.activeElement,
|
|
handler = target && ko.utils.domData.get(target, selectionChangeHandlerName);
|
|
if (handler) {
|
|
handler(event);
|
|
}
|
|
};
|
|
var registerForSelectionChangeEvent = function (element, handler) {
|
|
var ownerDoc = element.ownerDocument;
|
|
if (!ko.utils.domData.get(ownerDoc, selectionChangeRegisteredName)) {
|
|
ko.utils.domData.set(ownerDoc, selectionChangeRegisteredName, true);
|
|
ko.utils.registerEventHandler(ownerDoc, 'selectionchange', selectionChangeHandler);
|
|
}
|
|
ko.utils.domData.set(element, selectionChangeHandlerName, handler);
|
|
};
|
|
}
|
|
|
|
ko.bindingHandlers['textInput'] = {
|
|
'init': function (element, valueAccessor, allBindings) {
|
|
|
|
var previousElementValue = element.value,
|
|
timeoutHandle,
|
|
elementValueBeforeEvent;
|
|
|
|
var updateModel = function (event) {
|
|
clearTimeout(timeoutHandle);
|
|
elementValueBeforeEvent = timeoutHandle = undefined;
|
|
|
|
var elementValue = element.value;
|
|
if (previousElementValue !== elementValue) {
|
|
// Provide a way for tests to know exactly which event was processed
|
|
if (DEBUG && event) element['_ko_textInputProcessedEvent'] = event.type;
|
|
previousElementValue = elementValue;
|
|
ko.expressionRewriting.writeValueToProperty(valueAccessor(), allBindings, 'textInput', elementValue);
|
|
}
|
|
};
|
|
|
|
var deferUpdateModel = function (event) {
|
|
if (!timeoutHandle) {
|
|
// The elementValueBeforeEvent variable is set *only* during the brief gap between an
|
|
// event firing and the updateModel function running. This allows us to ignore model
|
|
// updates that are from the previous state of the element, usually due to techniques
|
|
// such as rateLimit. Such updates, if not ignored, can cause keystrokes to be lost.
|
|
elementValueBeforeEvent = element.value;
|
|
var handler = DEBUG ? updateModel.bind(element, {type: event.type}) : updateModel;
|
|
timeoutHandle = setTimeout(handler, 4);
|
|
}
|
|
};
|
|
|
|
var updateView = function () {
|
|
var modelValue = ko.utils.unwrapObservable(valueAccessor());
|
|
|
|
if (modelValue === null || modelValue === undefined) {
|
|
modelValue = '';
|
|
}
|
|
|
|
if (elementValueBeforeEvent !== undefined && modelValue === elementValueBeforeEvent) {
|
|
setTimeout(updateView, 4);
|
|
return;
|
|
}
|
|
|
|
// Update the element only if the element and model are different. On some browsers, updating the value
|
|
// will move the cursor to the end of the input, which would be bad while the user is typing.
|
|
if (element.value !== modelValue) {
|
|
previousElementValue = modelValue; // Make sure we ignore events (propertychange) that result from updating the value
|
|
element.value = modelValue;
|
|
}
|
|
};
|
|
|
|
var onEvent = function (event, handler) {
|
|
ko.utils.registerEventHandler(element, event, handler);
|
|
};
|
|
|
|
if (DEBUG && ko.bindingHandlers['textInput']['_forceUpdateOn']) {
|
|
// Provide a way for tests to specify exactly which events are bound
|
|
ko.utils.arrayForEach(ko.bindingHandlers['textInput']['_forceUpdateOn'], function(eventName) {
|
|
if (eventName.slice(0,5) == 'after') {
|
|
onEvent(eventName.slice(5), deferUpdateModel);
|
|
} else {
|
|
onEvent(eventName, updateModel);
|
|
}
|
|
});
|
|
} else {
|
|
if (ko.utils.ieVersion < 10) {
|
|
// Internet Explorer <= 8 doesn't support the 'input' event, but does include 'propertychange' that fires whenever
|
|
// any property of an element changes. Unlike 'input', it also fires if a property is changed from JavaScript code,
|
|
// but that's an acceptable compromise for this binding. IE 9 does support 'input', but since it doesn't fire it
|
|
// when using autocomplete, we'll use 'propertychange' for it also.
|
|
onEvent('propertychange', function(event) {
|
|
if (event.propertyName === 'value') {
|
|
updateModel(event);
|
|
}
|
|
});
|
|
|
|
if (ko.utils.ieVersion == 8) {
|
|
// IE 8 has a bug where it fails to fire 'propertychange' on the first update following a value change from
|
|
// JavaScript code. It also doesn't fire if you clear the entire value. To fix this, we bind to the following
|
|
// events too.
|
|
onEvent('keyup', updateModel); // A single keystoke
|
|
onEvent('keydown', updateModel); // The first character when a key is held down
|
|
}
|
|
if (ko.utils.ieVersion >= 8) {
|
|
// Internet Explorer 9 doesn't fire the 'input' event when deleting text, including using
|
|
// the backspace, delete, or ctrl-x keys, clicking the 'x' to clear the input, dragging text
|
|
// out of the field, and cutting or deleting text using the context menu. 'selectionchange'
|
|
// can detect all of those except dragging text out of the field, for which we use 'dragend'.
|
|
// These are also needed in IE8 because of the bug described above.
|
|
registerForSelectionChangeEvent(element, updateModel); // 'selectionchange' covers cut, paste, drop, delete, etc.
|
|
onEvent('dragend', deferUpdateModel);
|
|
}
|
|
} else {
|
|
// All other supported browsers support the 'input' event, which fires whenever the content of the element is changed
|
|
// through the user interface.
|
|
onEvent('input', updateModel);
|
|
|
|
if (safariVersion < 5 && ko.utils.tagNameLower(element) === "textarea") {
|
|
// Safari <5 doesn't fire the 'input' event for <textarea> elements (it does fire 'textInput'
|
|
// but only when typing). So we'll just catch as much as we can with keydown, cut, and paste.
|
|
onEvent('keydown', deferUpdateModel);
|
|
onEvent('paste', deferUpdateModel);
|
|
onEvent('cut', deferUpdateModel);
|
|
} else if (operaVersion < 11) {
|
|
// Opera 10 doesn't always fire the 'input' event for cut, paste, undo & drop operations.
|
|
// We can try to catch some of those using 'keydown'.
|
|
onEvent('keydown', deferUpdateModel);
|
|
} else if (firefoxVersion < 4.0) {
|
|
// Firefox <= 3.6 doesn't fire the 'input' event when text is filled in through autocomplete
|
|
onEvent('DOMAutoComplete', updateModel);
|
|
|
|
// Firefox <=3.5 doesn't fire the 'input' event when text is dropped into the input.
|
|
onEvent('dragdrop', updateModel); // <3.5
|
|
onEvent('drop', updateModel); // 3.5
|
|
}
|
|
}
|
|
}
|
|
|
|
// Bind to the change event so that we can catch programmatic updates of the value that fire this event.
|
|
onEvent('change', updateModel);
|
|
|
|
ko.computed(updateView, null, { disposeWhenNodeIsRemoved: element });
|
|
}
|
|
};
|
|
ko.expressionRewriting.twoWayBindings['textInput'] = true;
|
|
|
|
// textinput is an alias for textInput
|
|
ko.bindingHandlers['textinput'] = {
|
|
// preprocess is the only way to set up a full alias
|
|
'preprocess': function (value, name, addBinding) {
|
|
addBinding('textInput', value);
|
|
}
|
|
};
|
|
|
|
})();ko.bindingHandlers['uniqueName'] = {
|
|
'init': function (element, valueAccessor) {
|
|
if (valueAccessor()) {
|
|
var name = "ko_unique_" + (++ko.bindingHandlers['uniqueName'].currentIndex);
|
|
ko.utils.setElementName(element, name);
|
|
}
|
|
}
|
|
};
|
|
ko.bindingHandlers['uniqueName'].currentIndex = 0;
|
|
ko.bindingHandlers['value'] = {
|
|
'after': ['options', 'foreach'],
|
|
'init': function (element, valueAccessor, allBindings) {
|
|
// If the value binding is placed on a radio/checkbox, then just pass through to checkedValue and quit
|
|
if (element.tagName.toLowerCase() == "input" && (element.type == "checkbox" || element.type == "radio")) {
|
|
ko.applyBindingAccessorsToNode(element, { 'checkedValue': valueAccessor });
|
|
return;
|
|
}
|
|
|
|
// Always catch "change" event; possibly other events too if asked
|
|
var eventsToCatch = ["change"];
|
|
var requestedEventsToCatch = allBindings.get("valueUpdate");
|
|
var propertyChangedFired = false;
|
|
var elementValueBeforeEvent = null;
|
|
|
|
if (requestedEventsToCatch) {
|
|
if (typeof requestedEventsToCatch == "string") // Allow both individual event names, and arrays of event names
|
|
requestedEventsToCatch = [requestedEventsToCatch];
|
|
ko.utils.arrayPushAll(eventsToCatch, requestedEventsToCatch);
|
|
eventsToCatch = ko.utils.arrayGetDistinctValues(eventsToCatch);
|
|
}
|
|
|
|
var valueUpdateHandler = function() {
|
|
elementValueBeforeEvent = null;
|
|
propertyChangedFired = false;
|
|
var modelValue = valueAccessor();
|
|
var elementValue = ko.selectExtensions.readValue(element);
|
|
ko.expressionRewriting.writeValueToProperty(modelValue, allBindings, 'value', elementValue);
|
|
}
|
|
|
|
// Workaround for https://github.com/SteveSanderson/knockout/issues/122
|
|
// IE doesn't fire "change" events on textboxes if the user selects a value from its autocomplete list
|
|
var ieAutoCompleteHackNeeded = ko.utils.ieVersion && element.tagName.toLowerCase() == "input" && element.type == "text"
|
|
&& element.autocomplete != "off" && (!element.form || element.form.autocomplete != "off");
|
|
if (ieAutoCompleteHackNeeded && ko.utils.arrayIndexOf(eventsToCatch, "propertychange") == -1) {
|
|
ko.utils.registerEventHandler(element, "propertychange", function () { propertyChangedFired = true });
|
|
ko.utils.registerEventHandler(element, "focus", function () { propertyChangedFired = false });
|
|
ko.utils.registerEventHandler(element, "blur", function() {
|
|
if (propertyChangedFired) {
|
|
valueUpdateHandler();
|
|
}
|
|
});
|
|
}
|
|
|
|
ko.utils.arrayForEach(eventsToCatch, function(eventName) {
|
|
// The syntax "after<eventname>" means "run the handler asynchronously after the event"
|
|
// This is useful, for example, to catch "keydown" events after the browser has updated the control
|
|
// (otherwise, ko.selectExtensions.readValue(this) will receive the control's value *before* the key event)
|
|
var handler = valueUpdateHandler;
|
|
if (ko.utils.stringStartsWith(eventName, "after")) {
|
|
handler = function() {
|
|
// The elementValueBeforeEvent variable is non-null *only* during the brief gap between
|
|
// a keyX event firing and the valueUpdateHandler running, which is scheduled to happen
|
|
// at the earliest asynchronous opportunity. We store this temporary information so that
|
|
// if, between keyX and valueUpdateHandler, the underlying model value changes separately,
|
|
// we can overwrite that model value change with the value the user just typed. Otherwise,
|
|
// techniques like rateLimit can trigger model changes at critical moments that will
|
|
// override the user's inputs, causing keystrokes to be lost.
|
|
elementValueBeforeEvent = ko.selectExtensions.readValue(element);
|
|
setTimeout(valueUpdateHandler, 0);
|
|
};
|
|
eventName = eventName.substring("after".length);
|
|
}
|
|
ko.utils.registerEventHandler(element, eventName, handler);
|
|
});
|
|
|
|
var updateFromModel = function () {
|
|
var newValue = ko.utils.unwrapObservable(valueAccessor());
|
|
var elementValue = ko.selectExtensions.readValue(element);
|
|
|
|
if (elementValueBeforeEvent !== null && newValue === elementValueBeforeEvent) {
|
|
setTimeout(updateFromModel, 0);
|
|
return;
|
|
}
|
|
|
|
var valueHasChanged = (newValue !== elementValue);
|
|
|
|
if (valueHasChanged) {
|
|
if (ko.utils.tagNameLower(element) === "select") {
|
|
var allowUnset = allBindings.get('valueAllowUnset');
|
|
var applyValueAction = function () {
|
|
ko.selectExtensions.writeValue(element, newValue, allowUnset);
|
|
};
|
|
applyValueAction();
|
|
|
|
if (!allowUnset && newValue !== ko.selectExtensions.readValue(element)) {
|
|
// If you try to set a model value that can't be represented in an already-populated dropdown, reject that change,
|
|
// because you're not allowed to have a model value that disagrees with a visible UI selection.
|
|
ko.dependencyDetection.ignore(ko.utils.triggerEvent, null, [element, "change"]);
|
|
} else {
|
|
// Workaround for IE6 bug: It won't reliably apply values to SELECT nodes during the same execution thread
|
|
// right after you've changed the set of OPTION nodes on it. So for that node type, we'll schedule a second thread
|
|
// to apply the value as well.
|
|
setTimeout(applyValueAction, 0);
|
|
}
|
|
} else {
|
|
ko.selectExtensions.writeValue(element, newValue);
|
|
}
|
|
}
|
|
};
|
|
|
|
ko.computed(updateFromModel, null, { disposeWhenNodeIsRemoved: element });
|
|
},
|
|
'update': function() {} // Keep for backwards compatibility with code that may have wrapped value binding
|
|
};
|
|
ko.expressionRewriting.twoWayBindings['value'] = true;
|
|
ko.bindingHandlers['visible'] = {
|
|
'update': function (element, valueAccessor) {
|
|
var value = ko.utils.unwrapObservable(valueAccessor());
|
|
var isCurrentlyVisible = !(element.style.display == "none");
|
|
if (value && !isCurrentlyVisible)
|
|
element.style.display = "";
|
|
else if ((!value) && isCurrentlyVisible)
|
|
element.style.display = "none";
|
|
}
|
|
};
|
|
// 'click' is just a shorthand for the usual full-length event:{click:handler}
|
|
makeEventHandlerShortcut('click');
|
|
// If you want to make a custom template engine,
|
|
//
|
|
// [1] Inherit from this class (like ko.nativeTemplateEngine does)
|
|
// [2] Override 'renderTemplateSource', supplying a function with this signature:
|
|
//
|
|
// function (templateSource, bindingContext, options) {
|
|
// // - templateSource.text() is the text of the template you should render
|
|
// // - bindingContext.$data is the data you should pass into the template
|
|
// // - you might also want to make bindingContext.$parent, bindingContext.$parents,
|
|
// // and bindingContext.$root available in the template too
|
|
// // - options gives you access to any other properties set on "data-bind: { template: options }"
|
|
// // - templateDocument is the document object of the template
|
|
// //
|
|
// // Return value: an array of DOM nodes
|
|
// }
|
|
//
|
|
// [3] Override 'createJavaScriptEvaluatorBlock', supplying a function with this signature:
|
|
//
|
|
// function (script) {
|
|
// // Return value: Whatever syntax means "Evaluate the JavaScript statement 'script' and output the result"
|
|
// // For example, the jquery.tmpl template engine converts 'someScript' to '${ someScript }'
|
|
// }
|
|
//
|
|
// This is only necessary if you want to allow data-bind attributes to reference arbitrary template variables.
|
|
// If you don't want to allow that, you can set the property 'allowTemplateRewriting' to false (like ko.nativeTemplateEngine does)
|
|
// and then you don't need to override 'createJavaScriptEvaluatorBlock'.
|
|
|
|
ko.templateEngine = function () { };
|
|
|
|
ko.templateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options, templateDocument) {
|
|
throw new Error("Override renderTemplateSource");
|
|
};
|
|
|
|
ko.templateEngine.prototype['createJavaScriptEvaluatorBlock'] = function (script) {
|
|
throw new Error("Override createJavaScriptEvaluatorBlock");
|
|
};
|
|
|
|
ko.templateEngine.prototype['makeTemplateSource'] = function(template, templateDocument) {
|
|
// Named template
|
|
if (typeof template == "string") {
|
|
templateDocument = templateDocument || document;
|
|
var elem = templateDocument.getElementById(template);
|
|
if (!elem)
|
|
throw new Error("Cannot find template with ID " + template);
|
|
return new ko.templateSources.domElement(elem);
|
|
} else if ((template.nodeType == 1) || (template.nodeType == 8)) {
|
|
// Anonymous template
|
|
return new ko.templateSources.anonymousTemplate(template);
|
|
} else
|
|
throw new Error("Unknown template type: " + template);
|
|
};
|
|
|
|
ko.templateEngine.prototype['renderTemplate'] = function (template, bindingContext, options, templateDocument) {
|
|
var templateSource = this['makeTemplateSource'](template, templateDocument);
|
|
return this['renderTemplateSource'](templateSource, bindingContext, options, templateDocument);
|
|
};
|
|
|
|
ko.templateEngine.prototype['isTemplateRewritten'] = function (template, templateDocument) {
|
|
// Skip rewriting if requested
|
|
if (this['allowTemplateRewriting'] === false)
|
|
return true;
|
|
return this['makeTemplateSource'](template, templateDocument)['data']("isRewritten");
|
|
};
|
|
|
|
ko.templateEngine.prototype['rewriteTemplate'] = function (template, rewriterCallback, templateDocument) {
|
|
var templateSource = this['makeTemplateSource'](template, templateDocument);
|
|
var rewritten = rewriterCallback(templateSource['text']());
|
|
templateSource['text'](rewritten);
|
|
templateSource['data']("isRewritten", true);
|
|
};
|
|
|
|
ko.exportSymbol('templateEngine', ko.templateEngine);
|
|
|
|
ko.templateRewriting = (function () {
|
|
var memoizeDataBindingAttributeSyntaxRegex = /(<([a-z]+\d*)(?:\s+(?!data-bind\s*=\s*)[a-z0-9\-]+(?:=(?:\"[^\"]*\"|\'[^\']*\'|[^>]*))?)*\s+)data-bind\s*=\s*(["'])([\s\S]*?)\3/gi;
|
|
var memoizeVirtualContainerBindingSyntaxRegex = /<!--\s*ko\b\s*([\s\S]*?)\s*-->/g;
|
|
|
|
function validateDataBindValuesForRewriting(keyValueArray) {
|
|
var allValidators = ko.expressionRewriting.bindingRewriteValidators;
|
|
for (var i = 0; i < keyValueArray.length; i++) {
|
|
var key = keyValueArray[i]['key'];
|
|
if (allValidators.hasOwnProperty(key)) {
|
|
var validator = allValidators[key];
|
|
|
|
if (typeof validator === "function") {
|
|
var possibleErrorMessage = validator(keyValueArray[i]['value']);
|
|
if (possibleErrorMessage)
|
|
throw new Error(possibleErrorMessage);
|
|
} else if (!validator) {
|
|
throw new Error("This template engine does not support the '" + key + "' binding within its templates");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
function constructMemoizedTagReplacement(dataBindAttributeValue, tagToRetain, nodeName, templateEngine) {
|
|
var dataBindKeyValueArray = ko.expressionRewriting.parseObjectLiteral(dataBindAttributeValue);
|
|
validateDataBindValuesForRewriting(dataBindKeyValueArray);
|
|
var rewrittenDataBindAttributeValue = ko.expressionRewriting.preProcessBindings(dataBindKeyValueArray, {'valueAccessors':true});
|
|
|
|
// For no obvious reason, Opera fails to evaluate rewrittenDataBindAttributeValue unless it's wrapped in an additional
|
|
// anonymous function, even though Opera's built-in debugger can evaluate it anyway. No other browser requires this
|
|
// extra indirection.
|
|
var applyBindingsToNextSiblingScript =
|
|
"ko.__tr_ambtns(function($context,$element){return(function(){return{ " + rewrittenDataBindAttributeValue + " } })()},'" + nodeName.toLowerCase() + "')";
|
|
return templateEngine['createJavaScriptEvaluatorBlock'](applyBindingsToNextSiblingScript) + tagToRetain;
|
|
}
|
|
|
|
return {
|
|
ensureTemplateIsRewritten: function (template, templateEngine, templateDocument) {
|
|
if (!templateEngine['isTemplateRewritten'](template, templateDocument))
|
|
templateEngine['rewriteTemplate'](template, function (htmlString) {
|
|
return ko.templateRewriting.memoizeBindingAttributeSyntax(htmlString, templateEngine);
|
|
}, templateDocument);
|
|
},
|
|
|
|
memoizeBindingAttributeSyntax: function (htmlString, templateEngine) {
|
|
return htmlString.replace(memoizeDataBindingAttributeSyntaxRegex, function () {
|
|
return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[4], /* tagToRetain: */ arguments[1], /* nodeName: */ arguments[2], templateEngine);
|
|
}).replace(memoizeVirtualContainerBindingSyntaxRegex, function() {
|
|
return constructMemoizedTagReplacement(/* dataBindAttributeValue: */ arguments[1], /* tagToRetain: */ "<!-- ko -->", /* nodeName: */ "#comment", templateEngine);
|
|
});
|
|
},
|
|
|
|
applyMemoizedBindingsToNextSibling: function (bindings, nodeName) {
|
|
return ko.memoization.memoize(function (domNode, bindingContext) {
|
|
var nodeToBind = domNode.nextSibling;
|
|
if (nodeToBind && nodeToBind.nodeName.toLowerCase() === nodeName) {
|
|
ko.applyBindingAccessorsToNode(nodeToBind, bindings, bindingContext);
|
|
}
|
|
});
|
|
}
|
|
}
|
|
})();
|
|
|
|
|
|
// Exported only because it has to be referenced by string lookup from within rewritten template
|
|
ko.exportSymbol('__tr_ambtns', ko.templateRewriting.applyMemoizedBindingsToNextSibling);
|
|
(function() {
|
|
// A template source represents a read/write way of accessing a template. This is to eliminate the need for template loading/saving
|
|
// logic to be duplicated in every template engine (and means they can all work with anonymous templates, etc.)
|
|
//
|
|
// Two are provided by default:
|
|
// 1. ko.templateSources.domElement - reads/writes the text content of an arbitrary DOM element
|
|
// 2. ko.templateSources.anonymousElement - uses ko.utils.domData to read/write text *associated* with the DOM element, but
|
|
// without reading/writing the actual element text content, since it will be overwritten
|
|
// with the rendered template output.
|
|
// You can implement your own template source if you want to fetch/store templates somewhere other than in DOM elements.
|
|
// Template sources need to have the following functions:
|
|
// text() - returns the template text from your storage location
|
|
// text(value) - writes the supplied template text to your storage location
|
|
// data(key) - reads values stored using data(key, value) - see below
|
|
// data(key, value) - associates "value" with this template and the key "key". Is used to store information like "isRewritten".
|
|
//
|
|
// Optionally, template sources can also have the following functions:
|
|
// nodes() - returns a DOM element containing the nodes of this template, where available
|
|
// nodes(value) - writes the given DOM element to your storage location
|
|
// If a DOM element is available for a given template source, template engines are encouraged to use it in preference over text()
|
|
// for improved speed. However, all templateSources must supply text() even if they don't supply nodes().
|
|
//
|
|
// Once you've implemented a templateSource, make your template engine use it by subclassing whatever template engine you were
|
|
// using and overriding "makeTemplateSource" to return an instance of your custom template source.
|
|
|
|
ko.templateSources = {};
|
|
|
|
// ---- ko.templateSources.domElement -----
|
|
|
|
ko.templateSources.domElement = function(element) {
|
|
this.domElement = element;
|
|
}
|
|
|
|
ko.templateSources.domElement.prototype['text'] = function(/* valueToWrite */) {
|
|
var tagNameLower = ko.utils.tagNameLower(this.domElement),
|
|
elemContentsProperty = tagNameLower === "script" ? "text"
|
|
: tagNameLower === "textarea" ? "value"
|
|
: "innerHTML";
|
|
|
|
if (arguments.length == 0) {
|
|
return this.domElement[elemContentsProperty];
|
|
} else {
|
|
var valueToWrite = arguments[0];
|
|
if (elemContentsProperty === "innerHTML")
|
|
ko.utils.setHtml(this.domElement, valueToWrite);
|
|
else
|
|
this.domElement[elemContentsProperty] = valueToWrite;
|
|
}
|
|
};
|
|
|
|
var dataDomDataPrefix = ko.utils.domData.nextKey() + "_";
|
|
ko.templateSources.domElement.prototype['data'] = function(key /*, valueToWrite */) {
|
|
if (arguments.length === 1) {
|
|
return ko.utils.domData.get(this.domElement, dataDomDataPrefix + key);
|
|
} else {
|
|
ko.utils.domData.set(this.domElement, dataDomDataPrefix + key, arguments[1]);
|
|
}
|
|
};
|
|
|
|
// ---- ko.templateSources.anonymousTemplate -----
|
|
// Anonymous templates are normally saved/retrieved as DOM nodes through "nodes".
|
|
// For compatibility, you can also read "text"; it will be serialized from the nodes on demand.
|
|
// Writing to "text" is still supported, but then the template data will not be available as DOM nodes.
|
|
|
|
var anonymousTemplatesDomDataKey = ko.utils.domData.nextKey();
|
|
ko.templateSources.anonymousTemplate = function(element) {
|
|
this.domElement = element;
|
|
}
|
|
ko.templateSources.anonymousTemplate.prototype = new ko.templateSources.domElement();
|
|
ko.templateSources.anonymousTemplate.prototype.constructor = ko.templateSources.anonymousTemplate;
|
|
ko.templateSources.anonymousTemplate.prototype['text'] = function(/* valueToWrite */) {
|
|
if (arguments.length == 0) {
|
|
var templateData = ko.utils.domData.get(this.domElement, anonymousTemplatesDomDataKey) || {};
|
|
if (templateData.textData === undefined && templateData.containerData)
|
|
templateData.textData = templateData.containerData.innerHTML;
|
|
return templateData.textData;
|
|
} else {
|
|
var valueToWrite = arguments[0];
|
|
ko.utils.domData.set(this.domElement, anonymousTemplatesDomDataKey, {textData: valueToWrite});
|
|
}
|
|
};
|
|
ko.templateSources.domElement.prototype['nodes'] = function(/* valueToWrite */) {
|
|
if (arguments.length == 0) {
|
|
var templateData = ko.utils.domData.get(this.domElement, anonymousTemplatesDomDataKey) || {};
|
|
return templateData.containerData;
|
|
} else {
|
|
var valueToWrite = arguments[0];
|
|
ko.utils.domData.set(this.domElement, anonymousTemplatesDomDataKey, {containerData: valueToWrite});
|
|
}
|
|
};
|
|
|
|
ko.exportSymbol('templateSources', ko.templateSources);
|
|
ko.exportSymbol('templateSources.domElement', ko.templateSources.domElement);
|
|
ko.exportSymbol('templateSources.anonymousTemplate', ko.templateSources.anonymousTemplate);
|
|
})();
|
|
(function () {
|
|
var _templateEngine;
|
|
ko.setTemplateEngine = function (templateEngine) {
|
|
if ((templateEngine != undefined) && !(templateEngine instanceof ko.templateEngine))
|
|
throw new Error("templateEngine must inherit from ko.templateEngine");
|
|
_templateEngine = templateEngine;
|
|
}
|
|
|
|
function invokeForEachNodeInContinuousRange(firstNode, lastNode, action) {
|
|
var node, nextInQueue = firstNode, firstOutOfRangeNode = ko.virtualElements.nextSibling(lastNode);
|
|
while (nextInQueue && ((node = nextInQueue) !== firstOutOfRangeNode)) {
|
|
nextInQueue = ko.virtualElements.nextSibling(node);
|
|
action(node, nextInQueue);
|
|
}
|
|
}
|
|
|
|
function activateBindingsOnContinuousNodeArray(continuousNodeArray, bindingContext) {
|
|
// To be used on any nodes that have been rendered by a template and have been inserted into some parent element
|
|
// Walks through continuousNodeArray (which *must* be continuous, i.e., an uninterrupted sequence of sibling nodes, because
|
|
// the algorithm for walking them relies on this), and for each top-level item in the virtual-element sense,
|
|
// (1) Does a regular "applyBindings" to associate bindingContext with this node and to activate any non-memoized bindings
|
|
// (2) Unmemoizes any memos in the DOM subtree (e.g., to activate bindings that had been memoized during template rewriting)
|
|
|
|
if (continuousNodeArray.length) {
|
|
var firstNode = continuousNodeArray[0],
|
|
lastNode = continuousNodeArray[continuousNodeArray.length - 1],
|
|
parentNode = firstNode.parentNode,
|
|
provider = ko.bindingProvider['instance'],
|
|
preprocessNode = provider['preprocessNode'];
|
|
|
|
if (preprocessNode) {
|
|
invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node, nextNodeInRange) {
|
|
var nodePreviousSibling = node.previousSibling;
|
|
var newNodes = preprocessNode.call(provider, node);
|
|
if (newNodes) {
|
|
if (node === firstNode)
|
|
firstNode = newNodes[0] || nextNodeInRange;
|
|
if (node === lastNode)
|
|
lastNode = newNodes[newNodes.length - 1] || nodePreviousSibling;
|
|
}
|
|
});
|
|
|
|
// Because preprocessNode can change the nodes, including the first and last nodes, update continuousNodeArray to match.
|
|
// We need the full set, including inner nodes, because the unmemoize step might remove the first node (and so the real
|
|
// first node needs to be in the array).
|
|
continuousNodeArray.length = 0;
|
|
if (!firstNode) { // preprocessNode might have removed all the nodes, in which case there's nothing left to do
|
|
return;
|
|
}
|
|
if (firstNode === lastNode) {
|
|
continuousNodeArray.push(firstNode);
|
|
} else {
|
|
continuousNodeArray.push(firstNode, lastNode);
|
|
ko.utils.fixUpContinuousNodeArray(continuousNodeArray, parentNode);
|
|
}
|
|
}
|
|
|
|
// Need to applyBindings *before* unmemoziation, because unmemoization might introduce extra nodes (that we don't want to re-bind)
|
|
// whereas a regular applyBindings won't introduce new memoized nodes
|
|
invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node) {
|
|
if (node.nodeType === 1 || node.nodeType === 8)
|
|
ko.applyBindings(bindingContext, node);
|
|
});
|
|
invokeForEachNodeInContinuousRange(firstNode, lastNode, function(node) {
|
|
if (node.nodeType === 1 || node.nodeType === 8)
|
|
ko.memoization.unmemoizeDomNodeAndDescendants(node, [bindingContext]);
|
|
});
|
|
|
|
// Make sure any changes done by applyBindings or unmemoize are reflected in the array
|
|
ko.utils.fixUpContinuousNodeArray(continuousNodeArray, parentNode);
|
|
}
|
|
}
|
|
|
|
function getFirstNodeFromPossibleArray(nodeOrNodeArray) {
|
|
return nodeOrNodeArray.nodeType ? nodeOrNodeArray
|
|
: nodeOrNodeArray.length > 0 ? nodeOrNodeArray[0]
|
|
: null;
|
|
}
|
|
|
|
function executeTemplate(targetNodeOrNodeArray, renderMode, template, bindingContext, options) {
|
|
options = options || {};
|
|
var firstTargetNode = targetNodeOrNodeArray && getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
|
|
var templateDocument = (firstTargetNode || template || {}).ownerDocument;
|
|
var templateEngineToUse = (options['templateEngine'] || _templateEngine);
|
|
ko.templateRewriting.ensureTemplateIsRewritten(template, templateEngineToUse, templateDocument);
|
|
var renderedNodesArray = templateEngineToUse['renderTemplate'](template, bindingContext, options, templateDocument);
|
|
|
|
// Loosely check result is an array of DOM nodes
|
|
if ((typeof renderedNodesArray.length != "number") || (renderedNodesArray.length > 0 && typeof renderedNodesArray[0].nodeType != "number"))
|
|
throw new Error("Template engine must return an array of DOM nodes");
|
|
|
|
var haveAddedNodesToParent = false;
|
|
switch (renderMode) {
|
|
case "replaceChildren":
|
|
ko.virtualElements.setDomNodeChildren(targetNodeOrNodeArray, renderedNodesArray);
|
|
haveAddedNodesToParent = true;
|
|
break;
|
|
case "replaceNode":
|
|
ko.utils.replaceDomNodes(targetNodeOrNodeArray, renderedNodesArray);
|
|
haveAddedNodesToParent = true;
|
|
break;
|
|
case "ignoreTargetNode": break;
|
|
default:
|
|
throw new Error("Unknown renderMode: " + renderMode);
|
|
}
|
|
|
|
if (haveAddedNodesToParent) {
|
|
activateBindingsOnContinuousNodeArray(renderedNodesArray, bindingContext);
|
|
if (options['afterRender'])
|
|
ko.dependencyDetection.ignore(options['afterRender'], null, [renderedNodesArray, bindingContext['$data']]);
|
|
}
|
|
|
|
return renderedNodesArray;
|
|
}
|
|
|
|
function resolveTemplateName(template, data, context) {
|
|
// The template can be specified as:
|
|
if (ko.isObservable(template)) {
|
|
// 1. An observable, with string value
|
|
return template();
|
|
} else if (typeof template === 'function') {
|
|
// 2. A function of (data, context) returning a string
|
|
return template(data, context);
|
|
} else {
|
|
// 3. A string
|
|
return template;
|
|
}
|
|
}
|
|
|
|
ko.renderTemplate = function (template, dataOrBindingContext, options, targetNodeOrNodeArray, renderMode) {
|
|
options = options || {};
|
|
if ((options['templateEngine'] || _templateEngine) == undefined)
|
|
throw new Error("Set a template engine before calling renderTemplate");
|
|
renderMode = renderMode || "replaceChildren";
|
|
|
|
if (targetNodeOrNodeArray) {
|
|
var firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
|
|
|
|
var whenToDispose = function () { return (!firstTargetNode) || !ko.utils.domNodeIsAttachedToDocument(firstTargetNode); }; // Passive disposal (on next evaluation)
|
|
var activelyDisposeWhenNodeIsRemoved = (firstTargetNode && renderMode == "replaceNode") ? firstTargetNode.parentNode : firstTargetNode;
|
|
|
|
return ko.dependentObservable( // So the DOM is automatically updated when any dependency changes
|
|
function () {
|
|
// Ensure we've got a proper binding context to work with
|
|
var bindingContext = (dataOrBindingContext && (dataOrBindingContext instanceof ko.bindingContext))
|
|
? dataOrBindingContext
|
|
: new ko.bindingContext(ko.utils.unwrapObservable(dataOrBindingContext));
|
|
|
|
var templateName = resolveTemplateName(template, bindingContext['$data'], bindingContext),
|
|
renderedNodesArray = executeTemplate(targetNodeOrNodeArray, renderMode, templateName, bindingContext, options);
|
|
|
|
if (renderMode == "replaceNode") {
|
|
targetNodeOrNodeArray = renderedNodesArray;
|
|
firstTargetNode = getFirstNodeFromPossibleArray(targetNodeOrNodeArray);
|
|
}
|
|
},
|
|
null,
|
|
{ disposeWhen: whenToDispose, disposeWhenNodeIsRemoved: activelyDisposeWhenNodeIsRemoved }
|
|
);
|
|
} else {
|
|
// We don't yet have a DOM node to evaluate, so use a memo and render the template later when there is a DOM node
|
|
return ko.memoization.memoize(function (domNode) {
|
|
ko.renderTemplate(template, dataOrBindingContext, options, domNode, "replaceNode");
|
|
});
|
|
}
|
|
};
|
|
|
|
ko.renderTemplateForEach = function (template, arrayOrObservableArray, options, targetNode, parentBindingContext) {
|
|
// Since setDomNodeChildrenFromArrayMapping always calls executeTemplateForArrayItem and then
|
|
// activateBindingsCallback for added items, we can store the binding context in the former to use in the latter.
|
|
var arrayItemContext;
|
|
|
|
// This will be called by setDomNodeChildrenFromArrayMapping to get the nodes to add to targetNode
|
|
var executeTemplateForArrayItem = function (arrayValue, index) {
|
|
// Support selecting template as a function of the data being rendered
|
|
arrayItemContext = parentBindingContext['createChildContext'](arrayValue, options['as'], function(context) {
|
|
context['$index'] = index;
|
|
});
|
|
|
|
var templateName = resolveTemplateName(template, arrayValue, arrayItemContext);
|
|
return executeTemplate(null, "ignoreTargetNode", templateName, arrayItemContext, options);
|
|
}
|
|
|
|
// This will be called whenever setDomNodeChildrenFromArrayMapping has added nodes to targetNode
|
|
var activateBindingsCallback = function(arrayValue, addedNodesArray, index) {
|
|
activateBindingsOnContinuousNodeArray(addedNodesArray, arrayItemContext);
|
|
if (options['afterRender'])
|
|
options['afterRender'](addedNodesArray, arrayValue);
|
|
|
|
// release the "cache" variable, so that it can be collected by
|
|
// the GC when its value isn't used from within the bindings anymore.
|
|
arrayItemContext = null;
|
|
};
|
|
|
|
return ko.dependentObservable(function () {
|
|
var unwrappedArray = ko.utils.unwrapObservable(arrayOrObservableArray) || [];
|
|
if (typeof unwrappedArray.length == "undefined") // Coerce single value into array
|
|
unwrappedArray = [unwrappedArray];
|
|
|
|
// Filter out any entries marked as destroyed
|
|
var filteredArray = ko.utils.arrayFilter(unwrappedArray, function(item) {
|
|
return options['includeDestroyed'] || item === undefined || item === null || !ko.utils.unwrapObservable(item['_destroy']);
|
|
});
|
|
|
|
// Call setDomNodeChildrenFromArrayMapping, ignoring any observables unwrapped within (most likely from a callback function).
|
|
// If the array items are observables, though, they will be unwrapped in executeTemplateForArrayItem and managed within setDomNodeChildrenFromArrayMapping.
|
|
ko.dependencyDetection.ignore(ko.utils.setDomNodeChildrenFromArrayMapping, null, [targetNode, filteredArray, executeTemplateForArrayItem, options, activateBindingsCallback]);
|
|
|
|
}, null, { disposeWhenNodeIsRemoved: targetNode });
|
|
};
|
|
|
|
var templateComputedDomDataKey = ko.utils.domData.nextKey();
|
|
function disposeOldComputedAndStoreNewOne(element, newComputed) {
|
|
var oldComputed = ko.utils.domData.get(element, templateComputedDomDataKey);
|
|
if (oldComputed && (typeof(oldComputed.dispose) == 'function'))
|
|
oldComputed.dispose();
|
|
ko.utils.domData.set(element, templateComputedDomDataKey, (newComputed && newComputed.isActive()) ? newComputed : undefined);
|
|
}
|
|
|
|
ko.bindingHandlers['template'] = {
|
|
'init': function(element, valueAccessor) {
|
|
// Support anonymous templates
|
|
var bindingValue = ko.utils.unwrapObservable(valueAccessor());
|
|
if (typeof bindingValue == "string" || bindingValue['name']) {
|
|
// It's a named template - clear the element
|
|
ko.virtualElements.emptyNode(element);
|
|
} else if ('nodes' in bindingValue) {
|
|
// We've been given an array of DOM nodes. Save them as the template source.
|
|
// There is no known use case for the node array being an observable array (if the output
|
|
// varies, put that behavior *into* your template - that's what templates are for), and
|
|
// the implementation would be a mess, so assert that it's not observable.
|
|
var nodes = bindingValue['nodes'] || [];
|
|
if (ko.isObservable(nodes)) {
|
|
throw new Error('The "nodes" option must be a plain, non-observable array.');
|
|
}
|
|
var container = ko.utils.moveCleanedNodesToContainerElement(nodes); // This also removes the nodes from their current parent
|
|
new ko.templateSources.anonymousTemplate(element)['nodes'](container);
|
|
} else {
|
|
// It's an anonymous template - store the element contents, then clear the element
|
|
var templateNodes = ko.virtualElements.childNodes(element),
|
|
container = ko.utils.moveCleanedNodesToContainerElement(templateNodes); // This also removes the nodes from their current parent
|
|
new ko.templateSources.anonymousTemplate(element)['nodes'](container);
|
|
}
|
|
return { 'controlsDescendantBindings': true };
|
|
},
|
|
'update': function (element, valueAccessor, allBindings, viewModel, bindingContext) {
|
|
var value = valueAccessor(),
|
|
dataValue,
|
|
options = ko.utils.unwrapObservable(value),
|
|
shouldDisplay = true,
|
|
templateComputed = null,
|
|
templateName;
|
|
|
|
if (typeof options == "string") {
|
|
templateName = value;
|
|
options = {};
|
|
} else {
|
|
templateName = options['name'];
|
|
|
|
// Support "if"/"ifnot" conditions
|
|
if ('if' in options)
|
|
shouldDisplay = ko.utils.unwrapObservable(options['if']);
|
|
if (shouldDisplay && 'ifnot' in options)
|
|
shouldDisplay = !ko.utils.unwrapObservable(options['ifnot']);
|
|
|
|
dataValue = ko.utils.unwrapObservable(options['data']);
|
|
}
|
|
|
|
if ('foreach' in options) {
|
|
// Render once for each data point (treating data set as empty if shouldDisplay==false)
|
|
var dataArray = (shouldDisplay && options['foreach']) || [];
|
|
templateComputed = ko.renderTemplateForEach(templateName || element, dataArray, options, element, bindingContext);
|
|
} else if (!shouldDisplay) {
|
|
ko.virtualElements.emptyNode(element);
|
|
} else {
|
|
// Render once for this single data point (or use the viewModel if no data was provided)
|
|
var innerBindingContext = ('data' in options) ?
|
|
bindingContext['createChildContext'](dataValue, options['as']) : // Given an explitit 'data' value, we create a child binding context for it
|
|
bindingContext; // Given no explicit 'data' value, we retain the same binding context
|
|
templateComputed = ko.renderTemplate(templateName || element, innerBindingContext, options, element);
|
|
}
|
|
|
|
// It only makes sense to have a single template computed per element (otherwise which one should have its output displayed?)
|
|
disposeOldComputedAndStoreNewOne(element, templateComputed);
|
|
}
|
|
};
|
|
|
|
// Anonymous templates can't be rewritten. Give a nice error message if you try to do it.
|
|
ko.expressionRewriting.bindingRewriteValidators['template'] = function(bindingValue) {
|
|
var parsedBindingValue = ko.expressionRewriting.parseObjectLiteral(bindingValue);
|
|
|
|
if ((parsedBindingValue.length == 1) && parsedBindingValue[0]['unknown'])
|
|
return null; // It looks like a string literal, not an object literal, so treat it as a named template (which is allowed for rewriting)
|
|
|
|
if (ko.expressionRewriting.keyValueArrayContainsKey(parsedBindingValue, "name"))
|
|
return null; // Named templates can be rewritten, so return "no error"
|
|
return "This template engine does not support anonymous templates nested within its templates";
|
|
};
|
|
|
|
ko.virtualElements.allowedBindings['template'] = true;
|
|
})();
|
|
|
|
ko.exportSymbol('setTemplateEngine', ko.setTemplateEngine);
|
|
ko.exportSymbol('renderTemplate', ko.renderTemplate);
|
|
// Go through the items that have been added and deleted and try to find matches between them.
|
|
ko.utils.findMovesInArrayComparison = function (left, right, limitFailedCompares) {
|
|
if (left.length && right.length) {
|
|
var failedCompares, l, r, leftItem, rightItem;
|
|
for (failedCompares = l = 0; (!limitFailedCompares || failedCompares < limitFailedCompares) && (leftItem = left[l]); ++l) {
|
|
for (r = 0; rightItem = right[r]; ++r) {
|
|
if (leftItem['value'] === rightItem['value']) {
|
|
leftItem['moved'] = rightItem['index'];
|
|
rightItem['moved'] = leftItem['index'];
|
|
right.splice(r, 1); // This item is marked as moved; so remove it from right list
|
|
failedCompares = r = 0; // Reset failed compares count because we're checking for consecutive failures
|
|
break;
|
|
}
|
|
}
|
|
failedCompares += r;
|
|
}
|
|
}
|
|
};
|
|
|
|
ko.utils.compareArrays = (function () {
|
|
var statusNotInOld = 'added', statusNotInNew = 'deleted';
|
|
|
|
// Simple calculation based on Levenshtein distance.
|
|
function compareArrays(oldArray, newArray, options) {
|
|
// For backward compatibility, if the third arg is actually a bool, interpret
|
|
// it as the old parameter 'dontLimitMoves'. Newer code should use { dontLimitMoves: true }.
|
|
options = (typeof options === 'boolean') ? { 'dontLimitMoves': options } : (options || {});
|
|
oldArray = oldArray || [];
|
|
newArray = newArray || [];
|
|
|
|
if (oldArray.length <= newArray.length)
|
|
return compareSmallArrayToBigArray(oldArray, newArray, statusNotInOld, statusNotInNew, options);
|
|
else
|
|
return compareSmallArrayToBigArray(newArray, oldArray, statusNotInNew, statusNotInOld, options);
|
|
}
|
|
|
|
function compareSmallArrayToBigArray(smlArray, bigArray, statusNotInSml, statusNotInBig, options) {
|
|
var myMin = Math.min,
|
|
myMax = Math.max,
|
|
editDistanceMatrix = [],
|
|
smlIndex, smlIndexMax = smlArray.length,
|
|
bigIndex, bigIndexMax = bigArray.length,
|
|
compareRange = (bigIndexMax - smlIndexMax) || 1,
|
|
maxDistance = smlIndexMax + bigIndexMax + 1,
|
|
thisRow, lastRow,
|
|
bigIndexMaxForRow, bigIndexMinForRow;
|
|
|
|
for (smlIndex = 0; smlIndex <= smlIndexMax; smlIndex++) {
|
|
lastRow = thisRow;
|
|
editDistanceMatrix.push(thisRow = []);
|
|
bigIndexMaxForRow = myMin(bigIndexMax, smlIndex + compareRange);
|
|
bigIndexMinForRow = myMax(0, smlIndex - 1);
|
|
for (bigIndex = bigIndexMinForRow; bigIndex <= bigIndexMaxForRow; bigIndex++) {
|
|
if (!bigIndex)
|
|
thisRow[bigIndex] = smlIndex + 1;
|
|
else if (!smlIndex) // Top row - transform empty array into new array via additions
|
|
thisRow[bigIndex] = bigIndex + 1;
|
|
else if (smlArray[smlIndex - 1] === bigArray[bigIndex - 1])
|
|
thisRow[bigIndex] = lastRow[bigIndex - 1]; // copy value (no edit)
|
|
else {
|
|
var northDistance = lastRow[bigIndex] || maxDistance; // not in big (deletion)
|
|
var westDistance = thisRow[bigIndex - 1] || maxDistance; // not in small (addition)
|
|
thisRow[bigIndex] = myMin(northDistance, westDistance) + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
var editScript = [], meMinusOne, notInSml = [], notInBig = [];
|
|
for (smlIndex = smlIndexMax, bigIndex = bigIndexMax; smlIndex || bigIndex;) {
|
|
meMinusOne = editDistanceMatrix[smlIndex][bigIndex] - 1;
|
|
if (bigIndex && meMinusOne === editDistanceMatrix[smlIndex][bigIndex-1]) {
|
|
notInSml.push(editScript[editScript.length] = { // added
|
|
'status': statusNotInSml,
|
|
'value': bigArray[--bigIndex],
|
|
'index': bigIndex });
|
|
} else if (smlIndex && meMinusOne === editDistanceMatrix[smlIndex - 1][bigIndex]) {
|
|
notInBig.push(editScript[editScript.length] = { // deleted
|
|
'status': statusNotInBig,
|
|
'value': smlArray[--smlIndex],
|
|
'index': smlIndex });
|
|
} else {
|
|
--bigIndex;
|
|
--smlIndex;
|
|
if (!options['sparse']) {
|
|
editScript.push({
|
|
'status': "retained",
|
|
'value': bigArray[bigIndex] });
|
|
}
|
|
}
|
|
}
|
|
|
|
// Set a limit on the number of consecutive non-matching comparisons; having it a multiple of
|
|
// smlIndexMax keeps the time complexity of this algorithm linear.
|
|
ko.utils.findMovesInArrayComparison(notInSml, notInBig, smlIndexMax * 10);
|
|
|
|
return editScript.reverse();
|
|
}
|
|
|
|
return compareArrays;
|
|
})();
|
|
|
|
ko.exportSymbol('utils.compareArrays', ko.utils.compareArrays);
|
|
(function () {
|
|
// Objective:
|
|
// * Given an input array, a container DOM node, and a function from array elements to arrays of DOM nodes,
|
|
// map the array elements to arrays of DOM nodes, concatenate together all these arrays, and use them to populate the container DOM node
|
|
// * Next time we're given the same combination of things (with the array possibly having mutated), update the container DOM node
|
|
// so that its children is again the concatenation of the mappings of the array elements, but don't re-map any array elements that we
|
|
// previously mapped - retain those nodes, and just insert/delete other ones
|
|
|
|
// "callbackAfterAddingNodes" will be invoked after any "mapping"-generated nodes are inserted into the container node
|
|
// You can use this, for example, to activate bindings on those nodes.
|
|
|
|
function mapNodeAndRefreshWhenChanged(containerNode, mapping, valueToMap, callbackAfterAddingNodes, index) {
|
|
// Map this array value inside a dependentObservable so we re-map when any dependency changes
|
|
var mappedNodes = [];
|
|
var dependentObservable = ko.dependentObservable(function() {
|
|
var newMappedNodes = mapping(valueToMap, index, ko.utils.fixUpContinuousNodeArray(mappedNodes, containerNode)) || [];
|
|
|
|
// On subsequent evaluations, just replace the previously-inserted DOM nodes
|
|
if (mappedNodes.length > 0) {
|
|
ko.utils.replaceDomNodes(mappedNodes, newMappedNodes);
|
|
if (callbackAfterAddingNodes)
|
|
ko.dependencyDetection.ignore(callbackAfterAddingNodes, null, [valueToMap, newMappedNodes, index]);
|
|
}
|
|
|
|
// Replace the contents of the mappedNodes array, thereby updating the record
|
|
// of which nodes would be deleted if valueToMap was itself later removed
|
|
mappedNodes.length = 0;
|
|
ko.utils.arrayPushAll(mappedNodes, newMappedNodes);
|
|
}, null, { disposeWhenNodeIsRemoved: containerNode, disposeWhen: function() { return !ko.utils.anyDomNodeIsAttachedToDocument(mappedNodes); } });
|
|
return { mappedNodes : mappedNodes, dependentObservable : (dependentObservable.isActive() ? dependentObservable : undefined) };
|
|
}
|
|
|
|
var lastMappingResultDomDataKey = ko.utils.domData.nextKey();
|
|
|
|
ko.utils.setDomNodeChildrenFromArrayMapping = function (domNode, array, mapping, options, callbackAfterAddingNodes) {
|
|
// Compare the provided array against the previous one
|
|
array = array || [];
|
|
options = options || {};
|
|
var isFirstExecution = ko.utils.domData.get(domNode, lastMappingResultDomDataKey) === undefined;
|
|
var lastMappingResult = ko.utils.domData.get(domNode, lastMappingResultDomDataKey) || [];
|
|
var lastArray = ko.utils.arrayMap(lastMappingResult, function (x) { return x.arrayEntry; });
|
|
var editScript = ko.utils.compareArrays(lastArray, array, options['dontLimitMoves']);
|
|
|
|
// Build the new mapping result
|
|
var newMappingResult = [];
|
|
var lastMappingResultIndex = 0;
|
|
var newMappingResultIndex = 0;
|
|
|
|
var nodesToDelete = [];
|
|
var itemsToProcess = [];
|
|
var itemsForBeforeRemoveCallbacks = [];
|
|
var itemsForMoveCallbacks = [];
|
|
var itemsForAfterAddCallbacks = [];
|
|
var mapData;
|
|
|
|
function itemMovedOrRetained(editScriptIndex, oldPosition) {
|
|
mapData = lastMappingResult[oldPosition];
|
|
if (newMappingResultIndex !== oldPosition)
|
|
itemsForMoveCallbacks[editScriptIndex] = mapData;
|
|
// Since updating the index might change the nodes, do so before calling fixUpContinuousNodeArray
|
|
mapData.indexObservable(newMappingResultIndex++);
|
|
ko.utils.fixUpContinuousNodeArray(mapData.mappedNodes, domNode);
|
|
newMappingResult.push(mapData);
|
|
itemsToProcess.push(mapData);
|
|
}
|
|
|
|
function callCallback(callback, items) {
|
|
if (callback) {
|
|
for (var i = 0, n = items.length; i < n; i++) {
|
|
if (items[i]) {
|
|
ko.utils.arrayForEach(items[i].mappedNodes, function(node) {
|
|
callback(node, i, items[i].arrayEntry);
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
for (var i = 0, editScriptItem, movedIndex; editScriptItem = editScript[i]; i++) {
|
|
movedIndex = editScriptItem['moved'];
|
|
switch (editScriptItem['status']) {
|
|
case "deleted":
|
|
if (movedIndex === undefined) {
|
|
mapData = lastMappingResult[lastMappingResultIndex];
|
|
|
|
// Stop tracking changes to the mapping for these nodes
|
|
if (mapData.dependentObservable)
|
|
mapData.dependentObservable.dispose();
|
|
|
|
// Queue these nodes for later removal
|
|
nodesToDelete.push.apply(nodesToDelete, ko.utils.fixUpContinuousNodeArray(mapData.mappedNodes, domNode));
|
|
if (options['beforeRemove']) {
|
|
itemsForBeforeRemoveCallbacks[i] = mapData;
|
|
itemsToProcess.push(mapData);
|
|
}
|
|
}
|
|
lastMappingResultIndex++;
|
|
break;
|
|
|
|
case "retained":
|
|
itemMovedOrRetained(i, lastMappingResultIndex++);
|
|
break;
|
|
|
|
case "added":
|
|
if (movedIndex !== undefined) {
|
|
itemMovedOrRetained(i, movedIndex);
|
|
} else {
|
|
mapData = { arrayEntry: editScriptItem['value'], indexObservable: ko.observable(newMappingResultIndex++) };
|
|
newMappingResult.push(mapData);
|
|
itemsToProcess.push(mapData);
|
|
if (!isFirstExecution)
|
|
itemsForAfterAddCallbacks[i] = mapData;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Call beforeMove first before any changes have been made to the DOM
|
|
callCallback(options['beforeMove'], itemsForMoveCallbacks);
|
|
|
|
// Next remove nodes for deleted items (or just clean if there's a beforeRemove callback)
|
|
ko.utils.arrayForEach(nodesToDelete, options['beforeRemove'] ? ko.cleanNode : ko.removeNode);
|
|
|
|
// Next add/reorder the remaining items (will include deleted items if there's a beforeRemove callback)
|
|
for (var i = 0, nextNode = ko.virtualElements.firstChild(domNode), lastNode, node; mapData = itemsToProcess[i]; i++) {
|
|
// Get nodes for newly added items
|
|
if (!mapData.mappedNodes)
|
|
ko.utils.extend(mapData, mapNodeAndRefreshWhenChanged(domNode, mapping, mapData.arrayEntry, callbackAfterAddingNodes, mapData.indexObservable));
|
|
|
|
// Put nodes in the right place if they aren't there already
|
|
for (var j = 0; node = mapData.mappedNodes[j]; nextNode = node.nextSibling, lastNode = node, j++) {
|
|
if (node !== nextNode)
|
|
ko.virtualElements.insertAfter(domNode, node, lastNode);
|
|
}
|
|
|
|
// Run the callbacks for newly added nodes (for example, to apply bindings, etc.)
|
|
if (!mapData.initialized && callbackAfterAddingNodes) {
|
|
callbackAfterAddingNodes(mapData.arrayEntry, mapData.mappedNodes, mapData.indexObservable);
|
|
mapData.initialized = true;
|
|
}
|
|
}
|
|
|
|
// If there's a beforeRemove callback, call it after reordering.
|
|
// Note that we assume that the beforeRemove callback will usually be used to remove the nodes using
|
|
// some sort of animation, which is why we first reorder the nodes that will be removed. If the
|
|
// callback instead removes the nodes right away, it would be more efficient to skip reordering them.
|
|
// Perhaps we'll make that change in the future if this scenario becomes more common.
|
|
callCallback(options['beforeRemove'], itemsForBeforeRemoveCallbacks);
|
|
|
|
// Finally call afterMove and afterAdd callbacks
|
|
callCallback(options['afterMove'], itemsForMoveCallbacks);
|
|
callCallback(options['afterAdd'], itemsForAfterAddCallbacks);
|
|
|
|
// Store a copy of the array items we just considered so we can difference it next time
|
|
ko.utils.domData.set(domNode, lastMappingResultDomDataKey, newMappingResult);
|
|
}
|
|
})();
|
|
|
|
ko.exportSymbol('utils.setDomNodeChildrenFromArrayMapping', ko.utils.setDomNodeChildrenFromArrayMapping);
|
|
ko.nativeTemplateEngine = function () {
|
|
this['allowTemplateRewriting'] = false;
|
|
}
|
|
|
|
ko.nativeTemplateEngine.prototype = new ko.templateEngine();
|
|
ko.nativeTemplateEngine.prototype.constructor = ko.nativeTemplateEngine;
|
|
ko.nativeTemplateEngine.prototype['renderTemplateSource'] = function (templateSource, bindingContext, options, templateDocument) {
|
|
var useNodesIfAvailable = !(ko.utils.ieVersion < 9), // IE<9 cloneNode doesn't work properly
|
|
templateNodesFunc = useNodesIfAvailable ? templateSource['nodes'] : null,
|
|
templateNodes = templateNodesFunc ? templateSource['nodes']() : null;
|
|
|
|
if (templateNodes) {
|
|
return ko.utils.makeArray(templateNodes.cloneNode(true).childNodes);
|
|
} else {
|
|
var templateText = templateSource['text']();
|
|
return ko.utils.parseHtmlFragment(templateText, templateDocument);
|
|
}
|
|
};
|
|
|
|
ko.nativeTemplateEngine.instance = new ko.nativeTemplateEngine();
|
|
ko.setTemplateEngine(ko.nativeTemplateEngine.instance);
|
|
|
|
ko.exportSymbol('nativeTemplateEngine', ko.nativeTemplateEngine);
|
|
(function() {
|
|
ko.jqueryTmplTemplateEngine = function () {
|
|
// Detect which version of jquery-tmpl you're using. Unfortunately jquery-tmpl
|
|
// doesn't expose a version number, so we have to infer it.
|
|
// Note that as of Knockout 1.3, we only support jQuery.tmpl 1.0.0pre and later,
|
|
// which KO internally refers to as version "2", so older versions are no longer detected.
|
|
var jQueryTmplVersion = this.jQueryTmplVersion = (function() {
|
|
if (!jQueryInstance || !(jQueryInstance['tmpl']))
|
|
return 0;
|
|
// Since it exposes no official version number, we use our own numbering system. To be updated as jquery-tmpl evolves.
|
|
try {
|
|
if (jQueryInstance['tmpl']['tag']['tmpl']['open'].toString().indexOf('__') >= 0) {
|
|
// Since 1.0.0pre, custom tags should append markup to an array called "__"
|
|
return 2; // Final version of jquery.tmpl
|
|
}
|
|
} catch(ex) { /* Apparently not the version we were looking for */ }
|
|
|
|
return 1; // Any older version that we don't support
|
|
})();
|
|
|
|
function ensureHasReferencedJQueryTemplates() {
|
|
if (jQueryTmplVersion < 2)
|
|
throw new Error("Your version of jQuery.tmpl is too old. Please upgrade to jQuery.tmpl 1.0.0pre or later.");
|
|
}
|
|
|
|
function executeTemplate(compiledTemplate, data, jQueryTemplateOptions) {
|
|
return jQueryInstance['tmpl'](compiledTemplate, data, jQueryTemplateOptions);
|
|
}
|
|
|
|
this['renderTemplateSource'] = function(templateSource, bindingContext, options, templateDocument) {
|
|
templateDocument = templateDocument || document;
|
|
options = options || {};
|
|
ensureHasReferencedJQueryTemplates();
|
|
|
|
// Ensure we have stored a precompiled version of this template (don't want to reparse on every render)
|
|
var precompiled = templateSource['data']('precompiled');
|
|
if (!precompiled) {
|
|
var templateText = templateSource['text']() || "";
|
|
// Wrap in "with($whatever.koBindingContext) { ... }"
|
|
templateText = "{{ko_with $item.koBindingContext}}" + templateText + "{{/ko_with}}";
|
|
|
|
precompiled = jQueryInstance['template'](null, templateText);
|
|
templateSource['data']('precompiled', precompiled);
|
|
}
|
|
|
|
var data = [bindingContext['$data']]; // Prewrap the data in an array to stop jquery.tmpl from trying to unwrap any arrays
|
|
var jQueryTemplateOptions = jQueryInstance['extend']({ 'koBindingContext': bindingContext }, options['templateOptions']);
|
|
|
|
var resultNodes = executeTemplate(precompiled, data, jQueryTemplateOptions);
|
|
resultNodes['appendTo'](templateDocument.createElement("div")); // Using "appendTo" forces jQuery/jQuery.tmpl to perform necessary cleanup work
|
|
|
|
jQueryInstance['fragments'] = {}; // Clear jQuery's fragment cache to avoid a memory leak after a large number of template renders
|
|
return resultNodes;
|
|
};
|
|
|
|
this['createJavaScriptEvaluatorBlock'] = function(script) {
|
|
return "{{ko_code ((function() { return " + script + " })()) }}";
|
|
};
|
|
|
|
this['addTemplate'] = function(templateName, templateMarkup) {
|
|
document.write("<script type='text/html' id='" + templateName + "'>" + templateMarkup + "<" + "/script>");
|
|
};
|
|
|
|
if (jQueryTmplVersion > 0) {
|
|
jQueryInstance['tmpl']['tag']['ko_code'] = {
|
|
open: "__.push($1 || '');"
|
|
};
|
|
jQueryInstance['tmpl']['tag']['ko_with'] = {
|
|
open: "with($1) {",
|
|
close: "} "
|
|
};
|
|
}
|
|
};
|
|
|
|
ko.jqueryTmplTemplateEngine.prototype = new ko.templateEngine();
|
|
ko.jqueryTmplTemplateEngine.prototype.constructor = ko.jqueryTmplTemplateEngine;
|
|
|
|
// Use this one by default *only if jquery.tmpl is referenced*
|
|
var jqueryTmplTemplateEngineInstance = new ko.jqueryTmplTemplateEngine();
|
|
if (jqueryTmplTemplateEngineInstance.jQueryTmplVersion > 0)
|
|
ko.setTemplateEngine(jqueryTmplTemplateEngineInstance);
|
|
|
|
ko.exportSymbol('jqueryTmplTemplateEngine', ko.jqueryTmplTemplateEngine);
|
|
})();
|
|
}));
|
|
}());
|
|
})();
|
|
|
|
/*! Knockout projections plugin - version 1.1.0
|
|
------------------------------------------------------------------------------
|
|
Copyright (c) Microsoft Corporation
|
|
All rights reserved.
|
|
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
|
|
THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, MERCHANTABLITY OR NON-INFRINGEMENT.
|
|
See the Apache Version 2.0 License for specific language governing permissions and limitations under the License.
|
|
------------------------------------------------------------------------------
|
|
*/
|
|
|
|
(function(global, undefined) {
|
|
|
|
|
|
var exclusionMarker = {};
|
|
|
|
function StateItem(ko, inputItem, initialStateArrayIndex, initialOutputArrayIndex, mappingOptions, arrayOfState, outputObservableArray) {
|
|
// Capture state for later use
|
|
this.inputItem = inputItem;
|
|
this.stateArrayIndex = initialStateArrayIndex;
|
|
this.mappingOptions = mappingOptions;
|
|
this.arrayOfState = arrayOfState;
|
|
this.outputObservableArray = outputObservableArray;
|
|
this.outputArray = this.outputObservableArray.peek();
|
|
this.isIncluded = null; // Means 'not yet determined'
|
|
this.suppressNotification = false; // TODO: Instead of this technique, consider raising a sparse diff with a "mutated" entry when a single item changes, and not having any other change logic inside StateItem
|
|
|
|
// Set up observables
|
|
this.outputArrayIndex = ko.observable(initialOutputArrayIndex); // When excluded, it's the position the item would go if it became included
|
|
this.disposeFuncFromMostRecentMapping = null;
|
|
this.mappedValueComputed = ko.computed(this.mappingEvaluator, this);
|
|
this.mappedValueComputed.subscribe(this.onMappingResultChanged, this);
|
|
this.previousMappedValue = this.mappedValueComputed.peek();
|
|
}
|
|
|
|
StateItem.prototype.dispose = function() {
|
|
this.mappedValueComputed.dispose();
|
|
this.disposeResultFromMostRecentEvaluation();
|
|
};
|
|
|
|
StateItem.prototype.disposeResultFromMostRecentEvaluation = function() {
|
|
if (this.disposeFuncFromMostRecentMapping) {
|
|
this.disposeFuncFromMostRecentMapping();
|
|
this.disposeFuncFromMostRecentMapping = null;
|
|
}
|
|
|
|
if (this.mappingOptions.disposeItem) {
|
|
var mappedItem = this.mappedValueComputed();
|
|
this.mappingOptions.disposeItem(mappedItem);
|
|
}
|
|
};
|
|
|
|
StateItem.prototype.mappingEvaluator = function() {
|
|
if (this.isIncluded !== null) { // i.e., not first run
|
|
// This is a replace-in-place, so call any dispose callbacks
|
|
// we have for the earlier value
|
|
this.disposeResultFromMostRecentEvaluation();
|
|
}
|
|
|
|
var mappedValue;
|
|
if (this.mappingOptions.mapping) {
|
|
mappedValue = this.mappingOptions.mapping(this.inputItem, this.outputArrayIndex);
|
|
} else if (this.mappingOptions.mappingWithDisposeCallback) {
|
|
var mappedValueWithDisposeCallback = this.mappingOptions.mappingWithDisposeCallback(this.inputItem, this.outputArrayIndex);
|
|
if (!('mappedValue' in mappedValueWithDisposeCallback)) {
|
|
throw new Error('Return value from mappingWithDisposeCallback should have a \'mappedItem\' property.');
|
|
}
|
|
mappedValue = mappedValueWithDisposeCallback.mappedValue;
|
|
this.disposeFuncFromMostRecentMapping = mappedValueWithDisposeCallback.dispose;
|
|
} else {
|
|
throw new Error('No mapping callback given.');
|
|
}
|
|
|
|
var newInclusionState = mappedValue !== exclusionMarker;
|
|
|
|
// Inclusion state changes can *only* happen as a result of changing an individual item.
|
|
// Structural changes to the array can't cause this (because they don't cause any remapping;
|
|
// they only map newly added items which have no earlier inclusion state to change).
|
|
if (this.isIncluded !== newInclusionState) {
|
|
if (this.isIncluded !== null) { // i.e., not first run
|
|
this.moveSubsequentItemsBecauseInclusionStateChanged(newInclusionState);
|
|
}
|
|
|
|
this.isIncluded = newInclusionState;
|
|
}
|
|
|
|
return mappedValue;
|
|
};
|
|
|
|
StateItem.prototype.onMappingResultChanged = function(newValue) {
|
|
if (newValue !== this.previousMappedValue) {
|
|
if (this.isIncluded) {
|
|
this.outputArray.splice(this.outputArrayIndex.peek(), 1, newValue);
|
|
}
|
|
|
|
if (!this.suppressNotification) {
|
|
this.outputObservableArray.valueHasMutated();
|
|
}
|
|
|
|
this.previousMappedValue = newValue;
|
|
}
|
|
};
|
|
|
|
StateItem.prototype.moveSubsequentItemsBecauseInclusionStateChanged = function(newInclusionState) {
|
|
var outputArrayIndex = this.outputArrayIndex.peek(),
|
|
iterationIndex,
|
|
stateItem;
|
|
|
|
if (newInclusionState) {
|
|
// Shift all subsequent items along by one space, and increment their indexes.
|
|
// Note that changing their indexes might cause remapping, but won't affect their
|
|
// inclusion status (by definition, inclusion status must not be affected by index,
|
|
// otherwise you get undefined results) so there's no risk of a chain reaction.
|
|
this.outputArray.splice(outputArrayIndex, 0, null);
|
|
for (iterationIndex = this.stateArrayIndex + 1; iterationIndex < this.arrayOfState.length; iterationIndex++) {
|
|
stateItem = this.arrayOfState[iterationIndex];
|
|
stateItem.setOutputArrayIndexSilently(stateItem.outputArrayIndex.peek() + 1);
|
|
}
|
|
} else {
|
|
// Shift all subsequent items back by one space, and decrement their indexes
|
|
this.outputArray.splice(outputArrayIndex, 1);
|
|
for (iterationIndex = this.stateArrayIndex + 1; iterationIndex < this.arrayOfState.length; iterationIndex++) {
|
|
stateItem = this.arrayOfState[iterationIndex];
|
|
stateItem.setOutputArrayIndexSilently(stateItem.outputArrayIndex.peek() - 1);
|
|
}
|
|
}
|
|
};
|
|
|
|
StateItem.prototype.setOutputArrayIndexSilently = function(newIndex) {
|
|
// We only want to raise one output array notification per input array change,
|
|
// so during processing, we suppress notifications
|
|
this.suppressNotification = true;
|
|
this.outputArrayIndex(newIndex);
|
|
this.suppressNotification = false;
|
|
};
|
|
|
|
function getDiffEntryPostOperationIndex(diffEntry, editOffset) {
|
|
// The diff algorithm's "index" value refers to the output array for additions,
|
|
// but the "input" array for deletions. Get the output array position.
|
|
if (!diffEntry) { return null; }
|
|
switch (diffEntry.status) {
|
|
case 'added':
|
|
return diffEntry.index;
|
|
case 'deleted':
|
|
return diffEntry.index + editOffset;
|
|
default:
|
|
throw new Error('Unknown diff status: ' + diffEntry.status);
|
|
}
|
|
}
|
|
|
|
function insertOutputItem(ko, diffEntry, movedStateItems, stateArrayIndex, outputArrayIndex, mappingOptions, arrayOfState, outputObservableArray, outputArray) {
|
|
// Retain the existing mapped value if this is a move, otherwise perform mapping
|
|
var isMoved = typeof diffEntry.moved === 'number',
|
|
stateItem = isMoved ?
|
|
movedStateItems[diffEntry.moved] :
|
|
new StateItem(ko, diffEntry.value, stateArrayIndex, outputArrayIndex, mappingOptions, arrayOfState, outputObservableArray);
|
|
arrayOfState.splice(stateArrayIndex, 0, stateItem);
|
|
if (stateItem.isIncluded) {
|
|
outputArray.splice(outputArrayIndex, 0, stateItem.mappedValueComputed.peek());
|
|
}
|
|
|
|
// Update indexes
|
|
if (isMoved) {
|
|
// We don't change the index until *after* updating this item's position in outputObservableArray,
|
|
// because changing the index may trigger re-mapping, which in turn would cause the new
|
|
// value to be written to the 'index' position in the output array
|
|
stateItem.stateArrayIndex = stateArrayIndex;
|
|
stateItem.setOutputArrayIndexSilently(outputArrayIndex);
|
|
}
|
|
|
|
return stateItem;
|
|
}
|
|
|
|
function deleteOutputItem(diffEntry, arrayOfState, stateArrayIndex, outputArrayIndex, outputArray) {
|
|
var stateItem = arrayOfState.splice(stateArrayIndex, 1)[0];
|
|
if (stateItem.isIncluded) {
|
|
outputArray.splice(outputArrayIndex, 1);
|
|
}
|
|
if (typeof diffEntry.moved !== 'number') {
|
|
// Be careful to dispose only if this item really was deleted and not moved
|
|
stateItem.dispose();
|
|
}
|
|
}
|
|
|
|
function updateRetainedOutputItem(stateItem, stateArrayIndex, outputArrayIndex) {
|
|
// Just have to update its indexes
|
|
stateItem.stateArrayIndex = stateArrayIndex;
|
|
stateItem.setOutputArrayIndexSilently(outputArrayIndex);
|
|
|
|
// Return the new value for outputArrayIndex
|
|
return outputArrayIndex + (stateItem.isIncluded ? 1 : 0);
|
|
}
|
|
|
|
function makeLookupOfMovedStateItems(diff, arrayOfState) {
|
|
// Before we mutate arrayOfComputedMappedValues at all, grab a reference to each moved item
|
|
var movedStateItems = {};
|
|
for (var diffIndex = 0; diffIndex < diff.length; diffIndex++) {
|
|
var diffEntry = diff[diffIndex];
|
|
if (diffEntry.status === 'added' && (typeof diffEntry.moved === 'number')) {
|
|
movedStateItems[diffEntry.moved] = arrayOfState[diffEntry.moved];
|
|
}
|
|
}
|
|
return movedStateItems;
|
|
}
|
|
|
|
function getFirstModifiedOutputIndex(firstDiffEntry, arrayOfState, outputArray) {
|
|
// Work out where the first edit will affect the output array
|
|
// Then we can update outputArrayIndex incrementally while walking the diff list
|
|
if (!outputArray.length || !arrayOfState[firstDiffEntry.index]) {
|
|
// The first edit is beyond the end of the output or state array, so we must
|
|
// just be appending items.
|
|
return outputArray.length;
|
|
} else {
|
|
// The first edit corresponds to an existing state array item, so grab
|
|
// the first output array index from it.
|
|
return arrayOfState[firstDiffEntry.index].outputArrayIndex.peek();
|
|
}
|
|
}
|
|
|
|
function respondToArrayStructuralChanges(ko, inputObservableArray, arrayOfState, outputArray, outputObservableArray, mappingOptions) {
|
|
return inputObservableArray.subscribe(function(diff) {
|
|
if (!diff.length) {
|
|
return;
|
|
}
|
|
|
|
var movedStateItems = makeLookupOfMovedStateItems(diff, arrayOfState),
|
|
diffIndex = 0,
|
|
diffEntry = diff[0],
|
|
editOffset = 0, // A running total of (num(items added) - num(items deleted)) not accounting for filtering
|
|
outputArrayIndex = diffEntry && getFirstModifiedOutputIndex(diffEntry, arrayOfState, outputArray);
|
|
|
|
// Now iterate over the state array, at each stage checking whether the current item
|
|
// is the next one to have been edited. We can skip all the state array items whose
|
|
// indexes are less than the first edit index (i.e., diff[0].index).
|
|
for (var stateArrayIndex = diffEntry.index; diffEntry || (stateArrayIndex < arrayOfState.length); stateArrayIndex++) {
|
|
// Does the current diffEntry correspond to this position in the state array?
|
|
if (getDiffEntryPostOperationIndex(diffEntry, editOffset) === stateArrayIndex) {
|
|
// Yes - insert or delete the corresponding state and output items
|
|
switch (diffEntry.status) {
|
|
case 'added':
|
|
// Add to output, and update indexes
|
|
var stateItem = insertOutputItem(ko, diffEntry, movedStateItems, stateArrayIndex, outputArrayIndex, mappingOptions, arrayOfState, outputObservableArray, outputArray);
|
|
if (stateItem.isIncluded) {
|
|
outputArrayIndex++;
|
|
}
|
|
editOffset++;
|
|
break;
|
|
case 'deleted':
|
|
// Just erase from the output, and update indexes
|
|
deleteOutputItem(diffEntry, arrayOfState, stateArrayIndex, outputArrayIndex, outputArray);
|
|
editOffset--;
|
|
stateArrayIndex--; // To compensate for the "for" loop incrementing it
|
|
break;
|
|
default:
|
|
throw new Error('Unknown diff status: ' + diffEntry.status);
|
|
}
|
|
|
|
// We're done with this diff entry. Move on to the next one.
|
|
diffIndex++;
|
|
diffEntry = diff[diffIndex];
|
|
} else if (stateArrayIndex < arrayOfState.length) {
|
|
// No - the current item was retained. Just update its index.
|
|
outputArrayIndex = updateRetainedOutputItem(arrayOfState[stateArrayIndex], stateArrayIndex, outputArrayIndex);
|
|
}
|
|
}
|
|
|
|
outputObservableArray.valueHasMutated();
|
|
}, null, 'arrayChange');
|
|
}
|
|
|
|
// Mapping
|
|
function observableArrayMap(ko, mappingOptions) {
|
|
var inputObservableArray = this,
|
|
arrayOfState = [],
|
|
outputArray = [],
|
|
outputObservableArray = ko.observableArray(outputArray),
|
|
originalInputArrayContents = inputObservableArray.peek();
|
|
|
|
// Shorthand syntax - just pass a function instead of an options object
|
|
if (typeof mappingOptions === 'function') {
|
|
mappingOptions = { mapping: mappingOptions };
|
|
}
|
|
|
|
// Validate the options
|
|
if (mappingOptions.mappingWithDisposeCallback) {
|
|
if (mappingOptions.mapping || mappingOptions.disposeItem) {
|
|
throw new Error('\'mappingWithDisposeCallback\' cannot be used in conjunction with \'mapping\' or \'disposeItem\'.');
|
|
}
|
|
} else if (!mappingOptions.mapping) {
|
|
throw new Error('Specify either \'mapping\' or \'mappingWithDisposeCallback\'.');
|
|
}
|
|
|
|
// Initial state: map each of the inputs
|
|
for (var i = 0; i < originalInputArrayContents.length; i++) {
|
|
var inputItem = originalInputArrayContents[i],
|
|
stateItem = new StateItem(ko, inputItem, i, outputArray.length, mappingOptions, arrayOfState, outputObservableArray),
|
|
mappedValue = stateItem.mappedValueComputed.peek();
|
|
arrayOfState.push(stateItem);
|
|
|
|
if (stateItem.isIncluded) {
|
|
outputArray.push(mappedValue);
|
|
}
|
|
}
|
|
|
|
// If the input array changes structurally (items added or removed), update the outputs
|
|
var inputArraySubscription = respondToArrayStructuralChanges(ko, inputObservableArray, arrayOfState, outputArray, outputObservableArray, mappingOptions);
|
|
|
|
// Return value is a readonly computed which can track its own changes to permit chaining.
|
|
// When disposed, it cleans up everything it created.
|
|
var returnValue = ko.computed(outputObservableArray).extend({ trackArrayChanges: true }),
|
|
originalDispose = returnValue.dispose;
|
|
returnValue.dispose = function() {
|
|
inputArraySubscription.dispose();
|
|
ko.utils.arrayForEach(arrayOfState, function(stateItem) {
|
|
stateItem.dispose();
|
|
});
|
|
originalDispose.call(this, arguments);
|
|
};
|
|
|
|
// Make projections chainable
|
|
addProjectionFunctions(ko, returnValue);
|
|
|
|
return returnValue;
|
|
}
|
|
|
|
// Filtering
|
|
function observableArrayFilter(ko, predicate) {
|
|
return observableArrayMap.call(this, ko, function(item) {
|
|
return predicate(item) ? item : exclusionMarker;
|
|
});
|
|
}
|
|
|
|
// Attaching projection functions
|
|
// ------------------------------
|
|
//
|
|
// Builds a collection of projection functions that can quickly be attached to any object.
|
|
// The functions are predefined to retain 'this' and prefix the arguments list with the
|
|
// relevant 'ko' instance.
|
|
|
|
var projectionFunctionsCacheName = '_ko.projections.cache';
|
|
|
|
function attachProjectionFunctionsCache(ko) {
|
|
// Wraps callback so that, when invoked, its arguments list is prefixed by 'ko' and 'this'
|
|
function makeCaller(ko, callback) {
|
|
return function() {
|
|
return callback.apply(this, [ko].concat(Array.prototype.slice.call(arguments, 0)));
|
|
};
|
|
}
|
|
ko[projectionFunctionsCacheName] = {
|
|
map: makeCaller(ko, observableArrayMap),
|
|
filter: makeCaller(ko, observableArrayFilter)
|
|
};
|
|
}
|
|
|
|
function addProjectionFunctions(ko, target) {
|
|
ko.utils.extend(target, ko[projectionFunctionsCacheName]);
|
|
return target; // Enable chaining
|
|
}
|
|
|
|
// Module initialisation
|
|
// ---------------------
|
|
//
|
|
// When this script is first evaluated, it works out what kind of module loading scenario
|
|
// it is in (Node.js or a browser `<script>` tag), and then attaches itself to whichever
|
|
// instance of Knockout.js it can find.
|
|
|
|
function attachToKo(ko) {
|
|
ko.projections = {
|
|
_exclusionMarker: exclusionMarker
|
|
};
|
|
attachProjectionFunctionsCache(ko);
|
|
addProjectionFunctions(ko, ko.observableArray.fn); // Make all observable arrays projectable
|
|
}
|
|
|
|
// Determines which module loading scenario we're in, grabs dependencies, and attaches to KO
|
|
function prepareExports() {
|
|
if (typeof module !== 'undefined' && typeof module.exports !== 'undefined') {
|
|
// Node.js case - load KO synchronously
|
|
var ko = require('knockout');
|
|
attachToKo(ko);
|
|
module.exports = ko;
|
|
} else if (typeof define === 'function' && define.amd) {
|
|
define('knockout-projections',['knockout'], attachToKo);
|
|
} else if ('ko' in global) {
|
|
// Non-module case - attach to the global instance
|
|
attachToKo(global.ko);
|
|
}
|
|
}
|
|
|
|
prepareExports();
|
|
|
|
})(this);
|
|
|
|
/*
|
|
|
|
JS Signals <http://millermedeiros.github.com/js-signals/>
|
|
Released under the MIT license
|
|
Author: Miller Medeiros
|
|
Version: 1.0.0 - Build: 268 (2012/11/29 05:48 PM)
|
|
*/
|
|
(function(i){function h(a,b,c,d,e){this._listener=b;this._isOnce=c;this.context=d;this._signal=a;this._priority=e||0}function g(a,b){if(typeof a!=="function")throw Error("listener is a required param of {fn}() and should be a Function.".replace("{fn}",b));}function e(){this._bindings=[];this._prevParams=null;var a=this;this.dispatch=function(){e.prototype.dispatch.apply(a,arguments)}}h.prototype={active:!0,params:null,execute:function(a){var b;this.active&&this._listener&&(a=this.params?this.params.concat(a):
|
|
a,b=this._listener.apply(this.context,a),this._isOnce&&this.detach());return b},detach:function(){return this.isBound()?this._signal.remove(this._listener,this.context):null},isBound:function(){return!!this._signal&&!!this._listener},isOnce:function(){return this._isOnce},getListener:function(){return this._listener},getSignal:function(){return this._signal},_destroy:function(){delete this._signal;delete this._listener;delete this.context},toString:function(){return"[SignalBinding isOnce:"+this._isOnce+
|
|
", isBound:"+this.isBound()+", active:"+this.active+"]"}};e.prototype={VERSION:"1.0.0",memorize:!1,_shouldPropagate:!0,active:!0,_registerListener:function(a,b,c,d){var e=this._indexOfListener(a,c);if(e!==-1){if(a=this._bindings[e],a.isOnce()!==b)throw Error("You cannot add"+(b?"":"Once")+"() then add"+(!b?"":"Once")+"() the same listener without removing the relationship first.");}else a=new h(this,a,b,c,d),this._addBinding(a);this.memorize&&this._prevParams&&a.execute(this._prevParams);return a},
|
|
_addBinding:function(a){var b=this._bindings.length;do--b;while(this._bindings[b]&&a._priority<=this._bindings[b]._priority);this._bindings.splice(b+1,0,a)},_indexOfListener:function(a,b){for(var c=this._bindings.length,d;c--;)if(d=this._bindings[c],d._listener===a&&d.context===b)return c;return-1},has:function(a,b){return this._indexOfListener(a,b)!==-1},add:function(a,b,c){g(a,"add");return this._registerListener(a,!1,b,c)},addOnce:function(a,b,c){g(a,"addOnce");return this._registerListener(a,
|
|
!0,b,c)},remove:function(a,b){g(a,"remove");var c=this._indexOfListener(a,b);c!==-1&&(this._bindings[c]._destroy(),this._bindings.splice(c,1));return a},removeAll:function(){for(var a=this._bindings.length;a--;)this._bindings[a]._destroy();this._bindings.length=0},getNumListeners:function(){return this._bindings.length},halt:function(){this._shouldPropagate=!1},dispatch:function(a){if(this.active){var b=Array.prototype.slice.call(arguments),c=this._bindings.length,d;if(this.memorize)this._prevParams=
|
|
b;if(c){d=this._bindings.slice();this._shouldPropagate=!0;do c--;while(d[c]&&this._shouldPropagate&&d[c].execute(b)!==!1)}}},forget:function(){this._prevParams=null},dispose:function(){this.removeAll();delete this._bindings;delete this._prevParams},toString:function(){return"[Signal active:"+this.active+" numListeners:"+this.getNumListeners()+"]"}};var f=e;f.Signal=e;typeof define==="function"&&define.amd?define('signals',[],function(){return f}):typeof module!=="undefined"&&module.exports?module.exports=f:i.signals=
|
|
f})(this);
|
|
/** @license
|
|
* crossroads <http://millermedeiros.github.com/crossroads.js/>
|
|
* Author: Miller Medeiros | MIT License
|
|
* v0.12.2 (2015/07/31 18:37)
|
|
*/
|
|
;(function(){var a=function(a){function e(a,b){if(a.indexOf)return a.indexOf(b);var c=a.length;while(c--)if(a[c]===b)return c;return-1}function f(a,b){var c=e(a,b);c!==-1&&a.splice(c,1)}function g(a,b){return"[object "+b+"]"===Object.prototype.toString.call(a)}function h(a){return g(a,"RegExp")}function i(a){return g(a,"Array")}function j(a){return typeof a=="function"}function k(a){var b;return a===null||a==="null"?b=null:a==="true"?b=!0:a==="false"?b=!1:a===d||a==="undefined"?b=d:a===""||isNaN(a)?b=a:b=parseFloat(a),b}function l(a){var b=a.length,c=[];while(b--)c[b]=k(a[b]);return c}function m(a,b){var c=(a||"").replace("?","").split("&"),d=/([^=]+)=(.+)/,e=-1,f={},g,h,j,l;while(h=c[++e])g=h.indexOf("="),l=h.substring(0,g),j=decodeURIComponent(h.substring(g+1)),b!==!1&&(j=k(j)),l in f?i(f[l])?f[l].push(j):f[l]=[f[l],j]:f[l]=j;return f}function n(){this.bypassed=new a.Signal,this.routed=new a.Signal,this._routes=[],this._prevRoutes=[],this._piped=[],this.resetState()}function o(b,c,d,e){var f=h(b),g=e.patternLexer;this._router=e,this._pattern=b,this._paramsIds=f?null:g.getParamIds(b),this._optionalParamsIds=f?null:g.getOptionalParamsIds(b),this._matchRegexp=f?b:g.compilePattern(b,e.ignoreCase),this.matched=new a.Signal,this.switched=new a.Signal,c&&this.matched.add(c),this._priority=d||0}var b,c,d;return c=/t(.+)?/.exec("t")[1]==="",n.prototype={greedy:!1,greedyEnabled:!0,ignoreCase:!0,ignoreState:!1,shouldTypecast:!1,normalizeFn:null,resetState:function(){this._prevRoutes.length=0,this._prevMatchedRequest=null,this._prevBypassedRequest=null},create:function(){return new n},addRoute:function(a,b,c){var d=new o(a,b,c,this);return this._sortedInsert(d),d},removeRoute:function(a){f(this._routes,a),a._destroy()},removeAllRoutes:function(){var a=this.getNumRoutes();while(a--)this._routes[a]._destroy();this._routes.length=0},parse:function(a,b){a=a||"",b=b||[];if(!this.ignoreState&&(a===this._prevMatchedRequest||a===this._prevBypassedRequest))return;var c=this._getMatchedRoutes(a),d=0,e=c.length,f;if(e){this._prevMatchedRequest=a,this._notifyPrevRoutes(c,a),this._prevRoutes=c;while(d<e)f=c[d],f.route.matched.dispatch.apply(f.route.matched,b.concat(f.params)),f.isFirst=!d,this.routed.dispatch.apply(this.routed,b.concat([a,f])),d+=1}else this._prevBypassedRequest=a,this.bypassed.dispatch.apply(this.bypassed,b.concat([a]));this._pipeParse(a,b)},_notifyPrevRoutes:function(a,b){var c=0,d;while(d=this._prevRoutes[c++])d.route.switched&&this._didSwitch(d.route,a)&&d.route.switched.dispatch(b)},_didSwitch:function(a,b){var c,d=0;while(c=b[d++])if(c.route===a)return!1;return!0},_pipeParse:function(a,b){var c=0,d;while(d=this._piped[c++])d.parse(a,b)},getNumRoutes:function(){return this._routes.length},_sortedInsert:function(a){var b=this._routes,c=b.length;do--c;while(b[c]&&a._priority<=b[c]._priority);b.splice(c+1,0,a)},_getMatchedRoutes:function(a){var b=[],c=this._routes,d=c.length,e;while(e=c[--d]){(!b.length||this.greedy||e.greedy)&&e.match(a)&&b.push({route:e,params:e._getParamsArray(a)});if(!this.greedyEnabled&&b.length)break}return b},pipe:function(a){this._piped.push(a)},unpipe:function(a){f(this._piped,a)},toString:function(){return"[crossroads numRoutes:"+this.getNumRoutes()+"]"}},b=new n,b.VERSION="0.12.2",b.NORM_AS_ARRAY=function(a,b){return[b.vals_]},b.NORM_AS_OBJECT=function(a,b){return[b]},o.prototype={greedy:!1,rules:void 0,match:function(a){return a=a||"",this._matchRegexp.test(a)&&this._validateParams(a)},_validateParams:function(a){var b=this.rules,c=this._getParamsObject(a),d;for(d in b)if(d!=="normalize_"&&b.hasOwnProperty(d)&&!this._isValidParam(a,d,c))return!1;return!0},_isValidParam:function(a,b,c){var d=this.rules[b],f=c[b],g=!1,k=b.indexOf("?")===0;return f==null&&this._optionalParamsIds&&e(this._optionalParamsIds,b)!==-1?g=!0:h(d)?(k&&(f=c[b+"_"]),g=d.test(f)):i(d)?(k&&(f=c[b+"_"]),g=this._isValidArrayRule(d,f)):j(d)&&(g=d(f,a,c)),g},_isValidArrayRule:function(a,b){if(!this._router.ignoreCase)return e(a,b)!==-1;typeof b=="string"&&(b=b.toLowerCase());var c=a.length,d,f;while(c--){d=a[c],f=typeof d=="string"?d.toLowerCase():d;if(f===b)return!0}return!1},_getParamsObject:function(a){var b=this._router.shouldTypecast,d=this._router.patternLexer.getParamValues(a,this._matchRegexp,b),f={},g=d.length,h,i;while(g--)i=d[g],this._paramsIds&&(h=this._paramsIds[g],h.indexOf("?")===0&&i&&(f[h+"_"]=i,i=m(i,b),d[g]=i),c&&i===""&&e(this._optionalParamsIds,h)!==-1&&(i=void 0,d[g]=i),f[h]=i),f[g]=i;return f.request_=b?k(a):a,f.vals_=d,f},_getParamsArray:function(a){var b=this.rules?this.rules.normalize_:null,c;return b=b||this._router.normalizeFn,b&&j(b)?c=b(a,this._getParamsObject(a)):c=this._getParamsObject(a).vals_,c},interpolate:function(a){var b=this._router.patternLexer.interpolate(this._pattern,a);if(!this._validateParams(b))throw new Error("Generated string doesn't validate against `Route.rules`.");return b},dispose:function(){this._router.removeRoute(this)},_destroy:function(){this.matched.dispose(),this.switched.dispose(),this.matched=this.switched=this._pattern=this._matchRegexp=null},toString:function(){return'[Route pattern:"'+this._pattern+'", numListeners:'+this.matched.getNumListeners()+"]"}},n.prototype.patternLexer=function(){function k(){var a,b;for(a in e)e.hasOwnProperty(a)&&(b=e[a],b.id="__CR_"+a+"__",b.save="save"in b?b.save.replace("{{id}}",b.id):b.id,b.rRestore=new RegExp(b.id,"g"))}function m(a,b){var c=[],d;a.lastIndex=0;while(d=a.exec(b))c.push(d[1]);return c}function n(a){return m(d,a)}function o(a){return m(e.OP.rgx,a)}function p(d,e){return d=d||"",d&&(j===f?d=d.replace(b,""):j===h&&(d=d.replace(c,"")),d=q(d,"rgx","save"),d=d.replace(a,"\\$&"),d=q(d,"rRestore","res"),j===f&&(d="\\/?"+d)),j!==g&&(d+="\\/?"),new RegExp("^"+d+"$",e?"i":"")}function q(a,b,c){var d,f;for(f in e)e.hasOwnProperty(f)&&(d=e[f],a=a.replace(d[b],d[c]));return a}function r(a,b,c){var d=b.exec(a);return d&&(d.shift(),c&&(d=l(d))),d}function s(a,b){b=b||{};if(typeof a!="string")throw new Error("Route pattern should be a string.");var c=function(a,c){var d;c=c.substr(0,1)==="?"?c.substr(1):c;if(b[c]!=null){if(typeof b[c]=="object"){var e=[],f;for(var g in b[c]){f=b[c][g];if(i(f))for(var h in f)g.slice(-2)=="[]"?e.push(encodeURI(g.slice(0,-2))+"[]="+encodeURI(f[h])):e.push(encodeURI(g+"="+f[h]));else e.push(encodeURI(g+"="+f))}d="?"+e.join("&")}else d=String(b[c]);if(a.indexOf("*")===-1&&d.indexOf("/")!==-1)throw new Error('Invalid value "'+d+'" for segment "'+a+'".')}else{if(a.indexOf("{")!==-1)throw new Error("The segment "+a+" is required.");d=""}return d};return e.OS.trail||(e.OS.trail=new RegExp("(?:"+e.OS.id+")+$")),a.replace(e.OS.rgx,e.OS.save).replace(d,c).replace(e.OS.trail,"").replace(e.OS.rRestore,"/")}var a=/[\\.+*?\^$\[\](){}\/'#]/g,b=/^\/|\/$/g,c=/\/$/g,d=/(?:\{|:)([^}:]+)(?:\}|:)/g,e={OS:{rgx:/([:}]|\w(?=\/))\/?(:|(?:\{\?))/g,save:"$1{{id}}$2",res:"\\/?"},RS:{rgx:/([:}])\/?(\{)/g,save:"$1{{id}}$2",res:"\\/"},RQ:{rgx:/\{\?([^}]+)\}/g,res:"\\?([^#]+)"},OQ:{rgx:/:\?([^:]+):/g,res:"(?:\\?([^#]*))?"},OR:{rgx:/:([^:]+)\*:/g,res:"(.*)?"},RR:{rgx:/\{([^}]+)\*\}/g,res:"(.+)"},RP:{rgx:/\{([^}]+)\}/g,res:"([^\\/?]+)"},OP:{rgx:/:([^:]+):/g,res:"([^\\/?]+)?/?"}},f=1,g=2,h=3,j=f;return k(),{strict:function(){j=g},loose:function(){j=f},legacy:function(){j=h},getParamIds:n,getOptionalParamsIds:o,getParamValues:r,compilePattern:p,interpolate:s}}(),b};typeof define=="function"&&define.amd?define('crossroads',["signals"],a):typeof module!="undefined"&&module.exports?module.exports=a(require("signals")):window.crossroads=a(window.signals)})();
|
|
/*!
|
|
* Hasher <http://github.com/millermedeiros/hasher>
|
|
* @author Miller Medeiros
|
|
* @version 1.2.0 (2013/11/11 03:18 PM)
|
|
* Released under the MIT License
|
|
*/
|
|
(function(){var a=function(b){var c=(function(k){var p=25,r=k.document,n=k.history,x=b.Signal,f,v,m,F,d,D,t=/#(.*)$/,j=/(\?.*)|(\#.*)/,g=/^\#/,i=(!+"\v1"),B=("onhashchange" in k)&&r.documentMode!==7,e=i&&!B,s=(location.protocol==="file:");function o(G){return String(G||"").replace(/\W/g,"\\$&")}function u(H){if(!H){return""}var G=new RegExp("^"+o(f.prependHash)+"|"+o(f.appendHash)+"$","g");return H.replace(G,"")}function E(){var G=t.exec(f.getURL());var I=(G&&G[1])||"";try{return f.raw?I:decodeURIComponent(I)}catch(H){return I}}function A(){return(d)?d.contentWindow.frameHash:null}function z(){d=r.createElement("iframe");d.src="about:blank";d.style.display="none";r.body.appendChild(d)}function h(){if(d&&v!==A()){var G=d.contentWindow.document;G.open();G.write("<html><head><title>"+r.title+'</title><script type="text/javascript">var frameHash="'+v+'";<\/script></head><body> </body></html>');G.close()}}function l(G,H){if(v!==G){var I=v;v=G;if(e){if(!H){h()}else{d.contentWindow.frameHash=G}}f.changed.dispatch(u(G),u(I))}}if(e){D=function(){var H=E(),G=A();if(G!==v&&G!==H){f.setHash(u(G))}else{if(H!==v){l(H)}}}}else{D=function(){var G=E();if(G!==v){l(G)}}}function C(I,G,H){if(I.addEventListener){I.addEventListener(G,H,false)}else{if(I.attachEvent){I.attachEvent("on"+G,H)}}}function y(I,G,H){if(I.removeEventListener){I.removeEventListener(G,H,false)}else{if(I.detachEvent){I.detachEvent("on"+G,H)}}}function q(H){H=Array.prototype.slice.call(arguments);var G=H.join(f.separator);G=G?f.prependHash+G.replace(g,"")+f.appendHash:G;return G}function w(G){G=encodeURI(G);if(i&&s){G=G.replace(/\?/,"%3F")}return G}f={VERSION:"1.2.0",raw:false,appendHash:"",prependHash:"/",separator:"/",changed:new x(),stopped:new x(),initialized:new x(),init:function(){if(F){return}v=E();if(B){C(k,"hashchange",D)}else{if(e){if(!d){z()}h()}m=setInterval(D,p)}F=true;f.initialized.dispatch(u(v))},stop:function(){if(!F){return}if(B){y(k,"hashchange",D)}else{clearInterval(m);m=null}F=false;f.stopped.dispatch(u(v))},isActive:function(){return F},getURL:function(){return k.location.href},getBaseURL:function(){return f.getURL().replace(j,"")},setHash:function(G){G=q.apply(null,arguments);if(G!==v){l(G);if(G===v){if(!f.raw){G=w(G)}k.location.hash="#"+G}}},replaceHash:function(G){G=q.apply(null,arguments);if(G!==v){l(G,true);if(G===v){if(!f.raw){G=w(G)}k.location.replace("#"+G)}}},getHash:function(){return u(v)},getHashAsArray:function(){return f.getHash().split(f.separator)},dispose:function(){f.stop();f.initialized.dispose();f.stopped.dispose();f.changed.dispose();d=f=k.hasher=null},toString:function(){return'[hasher version="'+f.VERSION+'" hash="'+f.getHash()+'"]'}};f.initialized.memorize=true;return f}(window));return c};if(typeof define==="function"&&define.amd){define('hasher',["signals"],a)}else{if(typeof exports==="object"){module.exports=a(require("signals"))}else{window.hasher=a(window.signals)}}}());
|
|
define('app/router',['exports', 'module', 'knockout', 'crossroads', 'hasher'], function (exports, module, _knockout, _crossroads, _hasher) {
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var _ko = _interopRequireDefault(_knockout);
|
|
|
|
var _crossroads2 = _interopRequireDefault(_crossroads);
|
|
|
|
var _hasher2 = _interopRequireDefault(_hasher);
|
|
|
|
// This module configures crossroads.js, a routing library. If you prefer, you
|
|
// can use any other routing library (or none at all) as Knockout is designed to
|
|
// compose cleanly with external libraries.
|
|
//
|
|
// You *don't* have to follow the pattern established here (each route entry
|
|
// specifies a 'page', which is a Knockout component) - there's nothing built into
|
|
// Knockout that requires or even knows about this technique. It's just one of
|
|
// many possible ways of setting up client-side routes.
|
|
|
|
var Router = function Router(config) {
|
|
var _this = this;
|
|
|
|
_classCallCheck(this, Router);
|
|
|
|
this.currentRoute = _ko['default'].observable({});
|
|
|
|
// Configure Crossroads route handlers
|
|
_ko['default'].utils.arrayForEach(config.routes, function (route) {
|
|
_crossroads2['default'].addRoute(route.url, function (requestParams) {
|
|
_this.currentRoute(_ko['default'].utils.extend(requestParams, route.params));
|
|
});
|
|
});
|
|
|
|
// Activate Crossroads
|
|
_crossroads2['default'].normalizeFn = _crossroads2['default'].NORM_AS_OBJECT;
|
|
_hasher2['default'].initialized.add(function (hash) {
|
|
return _crossroads2['default'].parse(hash);
|
|
});
|
|
_hasher2['default'].changed.add(function (hash) {
|
|
return _crossroads2['default'].parse(hash);
|
|
});
|
|
_hasher2['default'].init();
|
|
}
|
|
|
|
// Create and export router instance
|
|
;
|
|
|
|
var routerInstance = new Router({
|
|
routes: [{ url: '', params: { page: 'home-page' } }, { url: 'about', params: { page: 'about-page' } }, { url: 'contact', params: { page: 'contact-page' } }, { url: 'login', params: { page: 'login' } }]
|
|
});
|
|
|
|
var postbox = new _ko['default'].subscribable();
|
|
|
|
module.exports = routerInstance;
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,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;
|
|
define('app/startup',['exports', 'jquery', 'bootstrap', 'knockout', 'knockout-projections', './router'], function (exports, _jquery, _bootstrap, _knockout, _knockoutProjections, _router) {
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
var _ko = _interopRequireDefault(_knockout);
|
|
|
|
window.shouter = new _ko['default'].subscribable();
|
|
|
|
_ko['default'].components.register('login', { require: 'components/login/login' });
|
|
|
|
// Components can be packaged as AMD modules, such as the following:
|
|
_ko['default'].components.register('nav-bar', { require: 'components/nav-bar/nav-bar' });
|
|
_ko['default'].components.register('home-page', { require: 'components/home-page/home' });
|
|
|
|
// ... or for template-only components, you can just point to a .html file directly:
|
|
_ko['default'].components.register('about-page', {
|
|
template: { require: 'text!components/about-page/about.html' }
|
|
});
|
|
|
|
_ko['default'].components.register('contact-page', {
|
|
template: { require: 'text!components/contact-page/contact.html' }
|
|
});
|
|
|
|
// [Scaffolded component registrations will be inserted here. To retain this feature, don't remove this comment.]
|
|
|
|
// Start the application
|
|
|
|
_ko['default'].applyBindings({ route: _router.currentRoute });
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,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;
|
|
/**
|
|
* @license text 2.0.15 Copyright jQuery Foundation and other contributors.
|
|
* Released under MIT license, http://github.com/requirejs/text/LICENSE
|
|
*/
|
|
/*jslint regexp: true */
|
|
/*global require, XMLHttpRequest, ActiveXObject,
|
|
define, window, process, Packages,
|
|
java, location, Components, FileUtils */
|
|
|
|
define('text',['module'], function (module) {
|
|
|
|
|
|
var text, fs, Cc, Ci, xpcIsWindows,
|
|
progIds = ['Msxml2.XMLHTTP', 'Microsoft.XMLHTTP', 'Msxml2.XMLHTTP.4.0'],
|
|
xmlRegExp = /^\s*<\?xml(\s)+version=[\'\"](\d)*.(\d)*[\'\"](\s)*\?>/im,
|
|
bodyRegExp = /<body[^>]*>\s*([\s\S]+)\s*<\/body>/im,
|
|
hasLocation = typeof location !== 'undefined' && location.href,
|
|
defaultProtocol = hasLocation && location.protocol && location.protocol.replace(/\:/, ''),
|
|
defaultHostName = hasLocation && location.hostname,
|
|
defaultPort = hasLocation && (location.port || undefined),
|
|
buildMap = {},
|
|
masterConfig = (module.config && module.config()) || {};
|
|
|
|
function useDefault(value, defaultValue) {
|
|
return value === undefined || value === '' ? defaultValue : value;
|
|
}
|
|
|
|
//Allow for default ports for http and https.
|
|
function isSamePort(protocol1, port1, protocol2, port2) {
|
|
if (port1 === port2) {
|
|
return true;
|
|
} else if (protocol1 === protocol2) {
|
|
if (protocol1 === 'http') {
|
|
return useDefault(port1, '80') === useDefault(port2, '80');
|
|
} else if (protocol1 === 'https') {
|
|
return useDefault(port1, '443') === useDefault(port2, '443');
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
text = {
|
|
version: '2.0.15',
|
|
|
|
strip: function (content) {
|
|
//Strips <?xml ...?> declarations so that external SVG and XML
|
|
//documents can be added to a document without worry. Also, if the string
|
|
//is an HTML document, only the part inside the body tag is returned.
|
|
if (content) {
|
|
content = content.replace(xmlRegExp, "");
|
|
var matches = content.match(bodyRegExp);
|
|
if (matches) {
|
|
content = matches[1];
|
|
}
|
|
} else {
|
|
content = "";
|
|
}
|
|
return content;
|
|
},
|
|
|
|
jsEscape: function (content) {
|
|
return content.replace(/(['\\])/g, '\\$1')
|
|
.replace(/[\f]/g, "\\f")
|
|
.replace(/[\b]/g, "\\b")
|
|
.replace(/[\n]/g, "\\n")
|
|
.replace(/[\t]/g, "\\t")
|
|
.replace(/[\r]/g, "\\r")
|
|
.replace(/[\u2028]/g, "\\u2028")
|
|
.replace(/[\u2029]/g, "\\u2029");
|
|
},
|
|
|
|
createXhr: masterConfig.createXhr || function () {
|
|
//Would love to dump the ActiveX crap in here. Need IE 6 to die first.
|
|
var xhr, i, progId;
|
|
if (typeof XMLHttpRequest !== "undefined") {
|
|
return new XMLHttpRequest();
|
|
} else if (typeof ActiveXObject !== "undefined") {
|
|
for (i = 0; i < 3; i += 1) {
|
|
progId = progIds[i];
|
|
try {
|
|
xhr = new ActiveXObject(progId);
|
|
} catch (e) {}
|
|
|
|
if (xhr) {
|
|
progIds = [progId]; // so faster next time
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return xhr;
|
|
},
|
|
|
|
/**
|
|
* Parses a resource name into its component parts. Resource names
|
|
* look like: module/name.ext!strip, where the !strip part is
|
|
* optional.
|
|
* @param {String} name the resource name
|
|
* @returns {Object} with properties "moduleName", "ext" and "strip"
|
|
* where strip is a boolean.
|
|
*/
|
|
parseName: function (name) {
|
|
var modName, ext, temp,
|
|
strip = false,
|
|
index = name.lastIndexOf("."),
|
|
isRelative = name.indexOf('./') === 0 ||
|
|
name.indexOf('../') === 0;
|
|
|
|
if (index !== -1 && (!isRelative || index > 1)) {
|
|
modName = name.substring(0, index);
|
|
ext = name.substring(index + 1);
|
|
} else {
|
|
modName = name;
|
|
}
|
|
|
|
temp = ext || modName;
|
|
index = temp.indexOf("!");
|
|
if (index !== -1) {
|
|
//Pull off the strip arg.
|
|
strip = temp.substring(index + 1) === "strip";
|
|
temp = temp.substring(0, index);
|
|
if (ext) {
|
|
ext = temp;
|
|
} else {
|
|
modName = temp;
|
|
}
|
|
}
|
|
|
|
return {
|
|
moduleName: modName,
|
|
ext: ext,
|
|
strip: strip
|
|
};
|
|
},
|
|
|
|
xdRegExp: /^((\w+)\:)?\/\/([^\/\\]+)/,
|
|
|
|
/**
|
|
* Is an URL on another domain. Only works for browser use, returns
|
|
* false in non-browser environments. Only used to know if an
|
|
* optimized .js version of a text resource should be loaded
|
|
* instead.
|
|
* @param {String} url
|
|
* @returns Boolean
|
|
*/
|
|
useXhr: function (url, protocol, hostname, port) {
|
|
var uProtocol, uHostName, uPort,
|
|
match = text.xdRegExp.exec(url);
|
|
if (!match) {
|
|
return true;
|
|
}
|
|
uProtocol = match[2];
|
|
uHostName = match[3];
|
|
|
|
uHostName = uHostName.split(':');
|
|
uPort = uHostName[1];
|
|
uHostName = uHostName[0];
|
|
|
|
return (!uProtocol || uProtocol === protocol) &&
|
|
(!uHostName || uHostName.toLowerCase() === hostname.toLowerCase()) &&
|
|
((!uPort && !uHostName) || isSamePort(uProtocol, uPort, protocol, port));
|
|
},
|
|
|
|
finishLoad: function (name, strip, content, onLoad) {
|
|
content = strip ? text.strip(content) : content;
|
|
if (masterConfig.isBuild) {
|
|
buildMap[name] = content;
|
|
}
|
|
onLoad(content);
|
|
},
|
|
|
|
load: function (name, req, onLoad, config) {
|
|
//Name has format: some.module.filext!strip
|
|
//The strip part is optional.
|
|
//if strip is present, then that means only get the string contents
|
|
//inside a body tag in an HTML string. For XML/SVG content it means
|
|
//removing the <?xml ...?> declarations so the content can be inserted
|
|
//into the current doc without problems.
|
|
|
|
// Do not bother with the work if a build and text will
|
|
// not be inlined.
|
|
if (config && config.isBuild && !config.inlineText) {
|
|
onLoad();
|
|
return;
|
|
}
|
|
|
|
masterConfig.isBuild = config && config.isBuild;
|
|
|
|
var parsed = text.parseName(name),
|
|
nonStripName = parsed.moduleName +
|
|
(parsed.ext ? '.' + parsed.ext : ''),
|
|
url = req.toUrl(nonStripName),
|
|
useXhr = (masterConfig.useXhr) ||
|
|
text.useXhr;
|
|
|
|
// Do not load if it is an empty: url
|
|
if (url.indexOf('empty:') === 0) {
|
|
onLoad();
|
|
return;
|
|
}
|
|
|
|
//Load the text. Use XHR if possible and in a browser.
|
|
if (!hasLocation || useXhr(url, defaultProtocol, defaultHostName, defaultPort)) {
|
|
text.get(url, function (content) {
|
|
text.finishLoad(name, parsed.strip, content, onLoad);
|
|
}, function (err) {
|
|
if (onLoad.error) {
|
|
onLoad.error(err);
|
|
}
|
|
});
|
|
} else {
|
|
//Need to fetch the resource across domains. Assume
|
|
//the resource has been optimized into a JS module. Fetch
|
|
//by the module name + extension, but do not include the
|
|
//!strip part to avoid file system issues.
|
|
req([nonStripName], function (content) {
|
|
text.finishLoad(parsed.moduleName + '.' + parsed.ext,
|
|
parsed.strip, content, onLoad);
|
|
});
|
|
}
|
|
},
|
|
|
|
write: function (pluginName, moduleName, write, config) {
|
|
if (buildMap.hasOwnProperty(moduleName)) {
|
|
var content = text.jsEscape(buildMap[moduleName]);
|
|
write.asModule(pluginName + "!" + moduleName,
|
|
"define(function () { return '" +
|
|
content +
|
|
"';});\n");
|
|
}
|
|
},
|
|
|
|
writeFile: function (pluginName, moduleName, req, write, config) {
|
|
var parsed = text.parseName(moduleName),
|
|
extPart = parsed.ext ? '.' + parsed.ext : '',
|
|
nonStripName = parsed.moduleName + extPart,
|
|
//Use a '.js' file name so that it indicates it is a
|
|
//script that can be loaded across domains.
|
|
fileName = req.toUrl(parsed.moduleName + extPart) + '.js';
|
|
|
|
//Leverage own load() method to load plugin value, but only
|
|
//write out values that do not have the strip argument,
|
|
//to avoid any potential issues with ! in file names.
|
|
text.load(nonStripName, req, function (value) {
|
|
//Use own write() method to construct full module value.
|
|
//But need to create shell that translates writeFile's
|
|
//write() to the right interface.
|
|
var textWrite = function (contents) {
|
|
return write(fileName, contents);
|
|
};
|
|
textWrite.asModule = function (moduleName, contents) {
|
|
return write.asModule(moduleName, fileName, contents);
|
|
};
|
|
|
|
text.write(pluginName, nonStripName, textWrite, config);
|
|
}, config);
|
|
}
|
|
};
|
|
|
|
if (masterConfig.env === 'node' || (!masterConfig.env &&
|
|
typeof process !== "undefined" &&
|
|
process.versions &&
|
|
!!process.versions.node &&
|
|
!process.versions['node-webkit'] &&
|
|
!process.versions['atom-shell'])) {
|
|
//Using special require.nodeRequire, something added by r.js.
|
|
fs = require.nodeRequire('fs');
|
|
|
|
text.get = function (url, callback, errback) {
|
|
try {
|
|
var file = fs.readFileSync(url, 'utf8');
|
|
//Remove BOM (Byte Mark Order) from utf8 files if it is there.
|
|
if (file[0] === '\uFEFF') {
|
|
file = file.substring(1);
|
|
}
|
|
callback(file);
|
|
} catch (e) {
|
|
if (errback) {
|
|
errback(e);
|
|
}
|
|
}
|
|
};
|
|
} else if (masterConfig.env === 'xhr' || (!masterConfig.env &&
|
|
text.createXhr())) {
|
|
text.get = function (url, callback, errback, headers) {
|
|
var xhr = text.createXhr(), header;
|
|
xhr.open('GET', url, true);
|
|
|
|
//Allow plugins direct access to xhr headers
|
|
if (headers) {
|
|
for (header in headers) {
|
|
if (headers.hasOwnProperty(header)) {
|
|
xhr.setRequestHeader(header.toLowerCase(), headers[header]);
|
|
}
|
|
}
|
|
}
|
|
|
|
//Allow overrides specified in config
|
|
if (masterConfig.onXhr) {
|
|
masterConfig.onXhr(xhr, url);
|
|
}
|
|
|
|
xhr.onreadystatechange = function (evt) {
|
|
var status, err;
|
|
//Do not explicitly handle errors, those should be
|
|
//visible via console output in the browser.
|
|
if (xhr.readyState === 4) {
|
|
status = xhr.status || 0;
|
|
if (status > 399 && status < 600) {
|
|
//An http 4xx or 5xx error. Signal an error.
|
|
err = new Error(url + ' HTTP status: ' + status);
|
|
err.xhr = xhr;
|
|
if (errback) {
|
|
errback(err);
|
|
}
|
|
} else {
|
|
callback(xhr.responseText);
|
|
}
|
|
|
|
if (masterConfig.onXhrComplete) {
|
|
masterConfig.onXhrComplete(xhr, url);
|
|
}
|
|
}
|
|
};
|
|
xhr.send(null);
|
|
};
|
|
} else if (masterConfig.env === 'rhino' || (!masterConfig.env &&
|
|
typeof Packages !== 'undefined' && typeof java !== 'undefined')) {
|
|
//Why Java, why is this so awkward?
|
|
text.get = function (url, callback) {
|
|
var stringBuffer, line,
|
|
encoding = "utf-8",
|
|
file = new java.io.File(url),
|
|
lineSeparator = java.lang.System.getProperty("line.separator"),
|
|
input = new java.io.BufferedReader(new java.io.InputStreamReader(new java.io.FileInputStream(file), encoding)),
|
|
content = '';
|
|
try {
|
|
stringBuffer = new java.lang.StringBuffer();
|
|
line = input.readLine();
|
|
|
|
// Byte Order Mark (BOM) - The Unicode Standard, version 3.0, page 324
|
|
// http://www.unicode.org/faq/utf_bom.html
|
|
|
|
// Note that when we use utf-8, the BOM should appear as "EF BB BF", but it doesn't due to this bug in the JDK:
|
|
// http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4508058
|
|
if (line && line.length() && line.charAt(0) === 0xfeff) {
|
|
// Eat the BOM, since we've already found the encoding on this file,
|
|
// and we plan to concatenating this buffer with others; the BOM should
|
|
// only appear at the top of a file.
|
|
line = line.substring(1);
|
|
}
|
|
|
|
if (line !== null) {
|
|
stringBuffer.append(line);
|
|
}
|
|
|
|
while ((line = input.readLine()) !== null) {
|
|
stringBuffer.append(lineSeparator);
|
|
stringBuffer.append(line);
|
|
}
|
|
//Make sure we return a JavaScript string and not a Java string.
|
|
content = String(stringBuffer.toString()); //String
|
|
} finally {
|
|
input.close();
|
|
}
|
|
callback(content);
|
|
};
|
|
} else if (masterConfig.env === 'xpconnect' || (!masterConfig.env &&
|
|
typeof Components !== 'undefined' && Components.classes &&
|
|
Components.interfaces)) {
|
|
//Avert your gaze!
|
|
Cc = Components.classes;
|
|
Ci = Components.interfaces;
|
|
Components.utils['import']('resource://gre/modules/FileUtils.jsm');
|
|
xpcIsWindows = ('@mozilla.org/windows-registry-key;1' in Cc);
|
|
|
|
text.get = function (url, callback) {
|
|
var inStream, convertStream, fileObj,
|
|
readData = {};
|
|
|
|
if (xpcIsWindows) {
|
|
url = url.replace(/\//g, '\\');
|
|
}
|
|
|
|
fileObj = new FileUtils.File(url);
|
|
|
|
//XPCOM, you so crazy
|
|
try {
|
|
inStream = Cc['@mozilla.org/network/file-input-stream;1']
|
|
.createInstance(Ci.nsIFileInputStream);
|
|
inStream.init(fileObj, 1, 0, false);
|
|
|
|
convertStream = Cc['@mozilla.org/intl/converter-input-stream;1']
|
|
.createInstance(Ci.nsIConverterInputStream);
|
|
convertStream.init(inStream, "utf-8", inStream.available(),
|
|
Ci.nsIConverterInputStream.DEFAULT_REPLACEMENT_CHARACTER);
|
|
|
|
convertStream.readString(inStream.available(), readData);
|
|
convertStream.close();
|
|
inStream.close();
|
|
callback(readData.value);
|
|
} catch (e) {
|
|
throw new Error((fileObj && fileObj.path || '') + ': ' + e);
|
|
}
|
|
};
|
|
}
|
|
return text;
|
|
});
|
|
|
|
define('text!components/nav-bar/nav-bar.html',[],function () { return '<!--\n The navigation UI that is docked to the top of the window. Most of this markup simply\n follows Bootstrap conventions. The only Knockout-specific parts are the data-bind\n attributes on the <li> elements.\n-->\n<nav class="navbar navbar-light bg-faded navbar-fixed-top" role="navigation">\n <div class="container">\n <div class="navbar-header">\n <button type="button" class="navbar-toggle" data-toggle="collapse" data-target=".navbar-collapse">\n <span class="sr-only">Toggle navigation</span>\n <span class="icon-bar"></span>\n <span class="icon-bar"></span>\n <span class="icon-bar"></span>\n </button>\n <a class="navbar-brand" href="#">OBrand Admin</a>\n </div>\n <div class="collapse navbar-collapse">\n\n <ul class="nav navbar-nav">\n <li data-bind="css: { active: route().page === \'home-page\' }">\n <a href="#">Home</a>\n </li>\n\n <li data-bind="css: { active: route().page === \'about-page\' }">\n <a href="#about">About</a>\n </li>\n\n <li data-bind="css: { active: route().page === \'contact-page\' }">\n <a href="#contact">Contact</a>\n </li>\n <!--data-bind=\'visible: loggedIn\'-->\n <li data-bind="css: { visible: loggedIn, active: route().page === \'profile-page\' }">\n <a href="#profile">Profile</a>\n </li>\n <li data-bind="css: { active: route().page === \'company-page\' }">\n <a href="#company">Company</a>\n </li>\n\n <li data-bind="css: { active: route().page === \'venues-page\' }">\n <a href="#venues">Venues</a>\n </li>\n\n <li data-bind="css: { active: route().page === \'beacons-page\' }">\n <a href="#beacons">Beacons</a>\n </li>\n\n <li data-bind="css: { active: route().page === \'pages-page\' }">\n <a href="#pages">Pages</a>\n </li>\n </ul>\n <div class="pull-xs-right">\n <ul class="nav navbar-nav">\n <li>\n <a href="#login">Login</a>\n </li>\n </ul>\n\n\n </div>\n\n\n </div>\n </div>\n</nav>\n';});
|
|
|
|
define('components/nav-bar/nav-bar',['exports', 'module', 'knockout', 'text!./nav-bar.html'], function (exports, module, _knockout, _textNavBarHtml) {
|
|
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var _ko = _interopRequireDefault(_knockout);
|
|
|
|
var _template = _interopRequireDefault(_textNavBarHtml);
|
|
|
|
var NavBarViewModel = function NavBarViewModel(params) {
|
|
_classCallCheck(this, NavBarViewModel);
|
|
|
|
var self = this;
|
|
// This viewmodel doesn't do anything except pass through the 'route' parameter to the view.
|
|
// You could remove this viewmodel entirely, and define 'nav-bar' as a template-only component.
|
|
// But in most apps, you'll want some viewmodel logic to determine what navigation options appear.
|
|
this.route = params.route;
|
|
this.loggedIn = _ko['default'].observable();
|
|
this._logginData = null;
|
|
|
|
window.shouter.subscribe(function (newValue) {
|
|
console.log('Subscribed: ', newValue);
|
|
if (newValue.hasOwnProperty('uid')) {
|
|
self.loggedIn(true);
|
|
self._logginData = newValue;
|
|
} else {
|
|
self.loggedIn(false);
|
|
self._logginData = null;
|
|
}
|
|
}, this, "loggedin");
|
|
};
|
|
|
|
module.exports = { viewModel: NavBarViewModel, template: _template['default'] };
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,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;
|
|
define('text!components/home-page/home.html',[],function () { return '<div class="alert alert-info">\n You can <a href="#login" class=\'alert-link\'>log in</a> with login <code>m@g.com</code> and password <code>password</code>.\n </div>\n\n<div class="jumbotron">\n <div class="container" style="background: linear-gradient(-226deg, rgba(142, 130, 236, 0.8) 0%, rgba(8, 81, 152, 0.92) 100%),url(\'images/skyview.jpg\');background-size:100%;">\n <span class="colour-bg">\n <h1>Welcome to OBrand</h1>\n <p>Warm and welcoming text about oBrand</p>\n\n </span>\n </div>\n</div>\n\n<p data-bind=\'text: message\'></p>\n\n<button data-bind=\'click: doSomething\'>Click me</button>\n';});
|
|
|
|
define('components/home-page/home',['exports', 'module', 'knockout', 'text!./home.html'], function (exports, module, _knockout, _textHomeHtml) {
|
|
|
|
|
|
var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var _ko = _interopRequireDefault(_knockout);
|
|
|
|
var _homeTemplate = _interopRequireDefault(_textHomeHtml);
|
|
|
|
var HomeViewModel = (function () {
|
|
function HomeViewModel(route) {
|
|
_classCallCheck(this, HomeViewModel);
|
|
|
|
this.message = _ko['default'].observable('Welcome to obrand-ko!');
|
|
}
|
|
|
|
_createClass(HomeViewModel, [{
|
|
key: 'doSomething',
|
|
value: function doSomething() {
|
|
this.message('You invoked doSomething() on the viewmodel.');
|
|
}
|
|
}]);
|
|
|
|
return HomeViewModel;
|
|
})();
|
|
|
|
module.exports = { viewModel: HomeViewModel, template: _homeTemplate['default'] };
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9zb3VyY2UvY29tcG9uZW50cy9ob21lLXBhZ2UvaG9tZS5qcyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7O1FBR00sYUFBYTtBQUNKLGlCQURULGFBQWEsQ0FDSCxLQUFLLEVBQUU7a0NBRGpCLGFBQWE7O0FBRVgsZ0JBQUksQ0FBQyxPQUFPLEdBQUcsZUFBRyxVQUFVLENBQUMsdUJBQXVCLENBQUMsQ0FBQztTQUN6RDs7cUJBSEMsYUFBYTs7bUJBS0osdUJBQUc7QUFDVixvQkFBSSxDQUFDLE9BQU8sQ0FBQyw2Q0FBNkMsQ0FBQyxDQUFDO2FBQy9EOzs7ZUFQQyxhQUFhOzs7cUJBVUosRUFBRSxTQUFTLEVBQUUsYUFBYSxFQUFFLFFBQVEsMEJBQWMsRUFBRSIsImZpbGUiOiJzcmMvY29tcG9uZW50cy9ob21lLXBhZ2UvaG9tZS5qcyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBrbyBmcm9tICdrbm9ja291dCc7XG5pbXBvcnQgaG9tZVRlbXBsYXRlIGZyb20gJ3RleHQhLi9ob21lLmh0bWwnO1xuXG5jbGFzcyBIb21lVmlld01vZGVsIHtcbiAgICBjb25zdHJ1Y3Rvcihyb3V0ZSkge1xuICAgICAgICB0aGlzLm1lc3NhZ2UgPSBrby5vYnNlcnZhYmxlKCdXZWxjb21lIHRvIG9icmFuZC1rbyEnKTtcbiAgICB9XG4gICAgXG4gICAgZG9Tb21ldGhpbmcoKSB7XG4gICAgICAgIHRoaXMubWVzc2FnZSgnWW91IGludm9rZWQgZG9Tb21ldGhpbmcoKSBvbiB0aGUgdmlld21vZGVsLicpO1xuICAgIH1cbn1cblxuZXhwb3J0IGRlZmF1bHQgeyB2aWV3TW9kZWw6IEhvbWVWaWV3TW9kZWwsIHRlbXBsYXRlOiBob21lVGVtcGxhdGUgfTsiXX0=;
|
|
define('text!components/about-page/about.html',[],function () { return '<div class="jumbotron">\n <div class="container">\n <h1>Welcome to OBrand</h1>\n <p>Warm and welcoming text about oBrand</p>\n </div>\n</div>';});
|
|
|
|
define('text!components/login/login.html',[],function () { return '\n<div class="container">\n <div class="col-sm-4 col-sm-offset-4">\n\n<form class="form-signin" data-bind="submit: authenticate">\n <div>\n <h2 class="form-signin-heading">Please login</h2>\n <label for="inputEmail" class="sr-only">Email address</label>\n <input type=\'email\' required="required" autofocus="autofocus" id=\'inputEmail\' placeholder=\'Email address\' class="form-control" data-bind="textInput: username">\n <label for="inputPassword" class="sr-only">Password</label>\n <input id=\'inputPassword\' placeholder=\'Password\' type=\'password\' class="form-control" required="required" data-bind="textInput: password">\n\n <div class="checkbox">\n <label>\n <input type="checkbox" value="remember-me"> Remember me\n </label>\n </div>\n <button type=\'submit\' class="btn btn-lg btn-primary btn-block">Login</button>\n </div>\n <div data-bind="visible: errorMessage">\n <div class="alert alert-danger" role="alert" data-bind="text: errorMessage"></div>\n <div class="alert alert-info">\n If you don\'t have an account, click <strong>SIGN UP</strong> and create one now.\n </div>\n\n </div>\n\n</form>\n\n </div>\n</div>\n\n\n<div class="alert alert-danger" role="alert" data-bind="text: authenticated"></div>\n<div class="alert alert-danger" role="alert" data-bind="text: auth_access_token"></div>\n<div class="alert alert-info" role="alert" data-bind="text: rawAccountDetails"></div>\n\n';});
|
|
|
|
define('components/login/login',['exports', 'module', 'knockout', 'text!./login.html'], function (exports, module, _knockout, _textLoginHtml) {
|
|
|
|
|
|
var _createClass = (function () { function defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ('value' in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } } return function (Constructor, protoProps, staticProps) { if (protoProps) defineProperties(Constructor.prototype, protoProps); if (staticProps) defineProperties(Constructor, staticProps); return Constructor; }; })();
|
|
|
|
function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { 'default': obj }; }
|
|
|
|
function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError('Cannot call a class as a function'); } }
|
|
|
|
var _ko = _interopRequireDefault(_knockout);
|
|
|
|
var _templateMarkup = _interopRequireDefault(_textLoginHtml);
|
|
|
|
var Login = (function () {
|
|
function Login(params) {
|
|
_classCallCheck(this, Login);
|
|
|
|
var self = this;
|
|
this.username = _ko['default'].observable('');
|
|
this.password = _ko['default'].observable('');
|
|
this.errorMessage = _ko['default'].observable('broken');
|
|
this.authenticated = _ko['default'].observable();
|
|
this.auth_access_token = _ko['default'].observable();
|
|
this.auth_account_id = _ko['default'].observable();
|
|
this.auth_username = _ko['default'].observable();
|
|
this.auth_account = _ko['default'].observable();
|
|
this.rawAccountDetails = _ko['default'].observable();
|
|
this.accountDetails = _ko['default'].observable();
|
|
|
|
this.authenticated.subscribe((function (v) {
|
|
this.auth_access_token(v.access_token);
|
|
this.auth_account_id(v.account_id);
|
|
this.auth_username(v.username);
|
|
this.auth_account(v.account);
|
|
|
|
console.log('+ setup');
|
|
$.ajaxSetup({
|
|
headers: {
|
|
'Authorization': 'Bearer ' + this.auth_access_token
|
|
}
|
|
});
|
|
console.log('- setup');
|
|
this.postAuthenticate(v.account_id);
|
|
}).bind(this));
|
|
|
|
this.rawAccountDetails.subscribe((function (v) {
|
|
if (v.hasOwnProperty('data')) {
|
|
this.accountDetails(v.data.attributes);
|
|
console.log(v);
|
|
console.log('rawAccountDetails.subscribe: ', this.accountDetails());
|
|
window.shouter.notifySubscribers(this.accountDetails(), "loggedin");
|
|
}
|
|
}).bind(this));
|
|
}
|
|
|
|
// Object {access_token: "secret token!", account_id: "BbW32qggFlg7zWHzknGjVe", username: "Martin", account: "martind2000@gmail.com"}
|
|
|
|
_createClass(Login, [{
|
|
key: 'dispose',
|
|
value: function dispose() {
|
|
// This runs when the component is torn down. Put here any logic necessary to clean up,
|
|
// for example cancelling setTimeouts or disposing Knockout subscriptions/computeds.
|
|
}
|
|
}, {
|
|
key: 'authenticate',
|
|
value: function authenticate() {
|
|
console.log('+++ AUTHENTICATE');
|
|
console.log(this.username());
|
|
|
|
var doLogin = function doLogin() {
|
|
var data = {
|
|
username: this.username(),
|
|
password: this.password(),
|
|
grant_type: 'password'
|
|
};
|
|
|
|
$.post('http://localhost:8086/token', data, this.authenticated, 'json');
|
|
};
|
|
|
|
doLogin.call(this);
|
|
}
|
|
}, {
|
|
key: 'postAuthenticate',
|
|
value: function postAuthenticate(accountID) {
|
|
console.log('+ postAuthenticate');
|
|
|
|
var getAccountDetails = function getAccountDetails() {
|
|
var self = this;
|
|
console.log('V1');
|
|
console.log('outer Setting header: ', this.auth_access_token());
|
|
var qs = ['http://localhost:8086/accounts/', accountID].join('');
|
|
console.log('getting account details');
|
|
var headers = {}; //{'accept': 'application/vnd.api+json', 'authorization': 'Bearer '+ this.auth_access_token() };
|
|
console.log(headers);
|
|
$.ajax({
|
|
url: qs,
|
|
type: 'GET',
|
|
headers: headers,
|
|
dataType: 'json',
|
|
success: function success(data) {
|
|
self.rawAccountDetails(data);
|
|
},
|
|
error: function error(e) {
|
|
console.error(e);
|
|
},
|
|
beforeSend: function beforeSend(xhr) {
|
|
xhr.setRequestHeader('Authorization', 'Bearer ' + self.auth_access_token());
|
|
}
|
|
});
|
|
};
|
|
getAccountDetails.call(this);
|
|
|
|
console.log('- postAuthenticate');
|
|
}
|
|
}]);
|
|
|
|
return Login;
|
|
})();
|
|
|
|
module.exports = { viewModel: Login, template: _templateMarkup['default'] };
|
|
});
|
|
//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/source/components/login/login.js"],"names":[],"mappings":";;;;;;;;;;;;;MAGM,KAAK;AACE,aADP,KAAK,CACG,MAAM,EAAE;4BADhB,KAAK;;AAEP,UAAI,IAAI,GAAG,IAAI,CAAC;AAChB,UAAI,CAAC,QAAQ,GAAG,eAAG,UAAU,CAAC,EAAE,CAAC,CAAC;AAClC,UAAI,CAAC,QAAQ,GAAG,eAAG,UAAU,CAAC,EAAE,CAAC,CAAC;AAClC,UAAI,CAAC,YAAY,GAAG,eAAG,UAAU,CAAC,QAAQ,CAAC,CAAC;AAC5C,UAAI,CAAC,aAAa,GAAG,eAAG,UAAU,EAAE,CAAC;AACrC,UAAI,CAAC,iBAAiB,GAAG,eAAG,UAAU,EAAE,CAAC;AACzC,UAAI,CAAC,eAAe,GAAG,eAAG,UAAU,EAAE,CAAC;AACvC,UAAI,CAAC,aAAa,GAAG,eAAG,UAAU,EAAE,CAAC;AACrC,UAAI,CAAC,YAAY,GAAG,eAAG,UAAU,EAAE,CAAC;AACpC,UAAI,CAAC,iBAAiB,GAAG,eAAG,UAAU,EAAE,CAAC;AACzC,UAAI,CAAC,cAAc,GAAG,eAAG,UAAU,EAAE,CAAC;;AAEtC,UAAI,CAAC,aAAa,CAAC,SAAS,CAAC,CAAA,UAAS,CAAC,EAAE;AACvC,YAAI,CAAC,iBAAiB,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC;AACvC,YAAI,CAAC,eAAe,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;AACnC,YAAI,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;AAC/B,YAAI,CAAC,YAAY,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;;AAE7B,eAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AACvB,SAAC,CAAC,SAAS,CAAC;AACV,iBAAO,EAAE;AACP,2BAAe,EAAC,SAAS,GAAG,IAAI,CAAC,iBAAiB;WACnD;SACF,CAAC,CAAC;AACH,eAAO,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC;AACvB,YAAI,CAAC,gBAAgB,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC;OACrC,CAAA,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;;AAGd,UAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC,CAAA,UAAS,CAAC,EAAE;AAC3C,YAAI,CAAC,CAAC,cAAc,CAAC,MAAM,CAAC,EAAC;AAC3B,cAAI,CAAC,cAAc,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,CAAC;AACvC,iBAAO,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC;AACf,iBAAO,CAAC,GAAG,CAAC,+BAA+B,EAAG,IAAI,CAAC,cAAc,EAAE,CAAC,CAAC;AACrE,gBAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,IAAI,CAAC,cAAc,EAAE,EAAE,UAAU,CAAC,CAAC;SAErE;OACF,CAAA,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;KACf;;;;iBAxCG,KAAK;;aA8CF,mBAAG;;;OAGT;;;aAEW,wBAAG;AACb,eAAO,CAAC,GAAG,CAAC,kBAAkB,CAAC,CAAC;AAChC,eAAO,CAAC,GAAG,CAAC,IAAI,CAAC,QAAQ,EAAE,CAAC,CAAC;;AAE7B,YAAI,OAAO,GAAG,SAAV,OAAO,GAAc;AACvB,cAAI,IAAI,GAAG;AACT,oBAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;AACzB,oBAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE;AACzB,sBAAU,EAAE,UAAU;WACvB,CAAC;;AAEF,WAAC,CAAC,IAAI,CAAC,6BAA6B,EAAE,IAAI,EAAE,IAAI,CAAC,aAAa,EAAE,MAAM,CAAC,CAAC;SACzE,CAAC;;AAEF,eAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;OACpB;;;aAEe,0BAAC,SAAS,EAAE;AAC1B,eAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;;AAElC,YAAI,iBAAiB,GAAG,SAApB,iBAAiB,GAAc;AACjC,cAAI,IAAI,GAAG,IAAI,CAAC;AAChB,iBAAO,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;AAClB,iBAAO,CAAC,GAAG,CAAC,wBAAwB,EAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;AAChE,cAAI,EAAE,GAAG,CAAC,iCAAiC,EAAE,SAAS,CAAC,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;AACjE,iBAAO,CAAC,GAAG,CAAC,yBAAyB,CAAC,CAAC;AACvC,cAAI,OAAO,GAAG,EAAE,CAAC;AACjB,iBAAO,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;AACrB,WAAC,CAAC,IAAI,CAAC;AACL,eAAG,EAAE,EAAE;AACP,gBAAI,EAAE,KAAK;AACX,mBAAO,EAAE,OAAO;AAChB,oBAAQ,EAAE,MAAM;AAChB,mBAAO,EAAE,iBAAS,IAAI,EAAE;AAAE,kBAAI,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;aAAE;AACzD,iBAAK,EAAE,eAAS,CAAC,EAAE;AAAE,qBAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;aAAE;AACxC,sBAAU,EAAE,oBAAU,GAAG,EAAE;AACnB,iBAAG,CAAC,gBAAgB,CAAC,eAAe,EAAG,SAAS,GAAE,IAAI,CAAC,iBAAiB,EAAE,CAAC,CAAC;aAC/E;WACN,CAAC,CAAC;SAGJ,CAAC;AACF,yBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;;AAE7B,eAAO,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC;OACnC;;;WAhGG,KAAK;;;mBA0GI,EAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,4BAAgB,EAAC","file":"src/components/login/login.js","sourcesContent":["import ko from 'knockout';\nimport templateMarkup from 'text!./login.html';\n\nclass Login {\n  constructor(params) {\n    var self = this;\n    this.username = ko.observable('');\n    this.password = ko.observable('');\n    this.errorMessage = ko.observable('broken');\n    this.authenticated = ko.observable();\n    this.auth_access_token = ko.observable();\n    this.auth_account_id = ko.observable();\n    this.auth_username = ko.observable();\n    this.auth_account = ko.observable();\n    this.rawAccountDetails = ko.observable();\n    this.accountDetails = ko.observable();\n\n    this.authenticated.subscribe(function(v) {\n      this.auth_access_token(v.access_token);\n      this.auth_account_id(v.account_id);\n      this.auth_username(v.username);\n      this.auth_account(v.account);\n\n      console.log('+ setup');\n      $.ajaxSetup({\n        headers: {\n          'Authorization':'Bearer ' + this.auth_access_token\n        }\n      });\n      console.log('- setup');\n      this.postAuthenticate(v.account_id);\n    }.bind(this));\n\n\n    this.rawAccountDetails.subscribe(function(v) {\n      if (v.hasOwnProperty('data')){\n        this.accountDetails(v.data.attributes);\n        console.log(v);\n        console.log('rawAccountDetails.subscribe: ' , this.accountDetails());\n        window.shouter.notifySubscribers(this.accountDetails(), \"loggedin\");\n\n      }\n    }.bind(this));\n  }\n\n\n\n  // Object {access_token: \"secret token!\", account_id: \"BbW32qggFlg7zWHzknGjVe\", username: \"Martin\", account: \"martind2000@gmail.com\"}\n\n  dispose() {\n    // This runs when the component is torn down. Put here any logic necessary to clean up,\n    // for example cancelling setTimeouts or disposing Knockout subscriptions/computeds.\n  }\n\n  authenticate() {\n    console.log('+++ AUTHENTICATE');\n    console.log(this.username());\n\n    var doLogin = function() {\n      var data = {\n        username: this.username(),\n        password: this.password(),\n        grant_type: 'password'\n      };\n\n      $.post('http://localhost:8086/token', data, this.authenticated, 'json');\n    };\n\n    doLogin.call(this);\n  }\n\n  postAuthenticate(accountID) {\n    console.log('+ postAuthenticate');\n\n    var getAccountDetails = function() {\n      var self = this;\n      console.log('V1');\n      console.log('outer Setting header: ', this.auth_access_token());\n      var qs = ['http://localhost:8086/accounts/', accountID].join('');\n      console.log('getting account details');\n      var headers = {};//{'accept': 'application/vnd.api+json', 'authorization': 'Bearer '+ this.auth_access_token() };\n      console.log(headers);\n      $.ajax({\n        url: qs,\n        type: 'GET',\n        headers: headers,\n        dataType: 'json',\n        success: function(data) { self.rawAccountDetails(data); },\n        error: function(e) { console.error(e); },\n        beforeSend: function (xhr) {\n                xhr.setRequestHeader('Authorization',  'Bearer '+ self.auth_access_token());\n            }\n      });\n\n\n    };\n    getAccountDetails.call(this);\n\n    console.log('- postAuthenticate');\n  }\n\n\n\n\n\n\n\n}\n\nexport default {viewModel: Login, template: templateMarkup};\n"]};
|
|
require(["app/startup"]);
|
|
|
|
require.config({
|
|
"bundles": {}
|
|
});
|