can
Version:
MIT-licensed, client-side, JavaScript framework that makes building rich web applications easy.
1,336 lines (1,332 loc) • 863 kB
JavaScript
/*[global-shim-start]*/
(function(exports, global, doEval){ // jshint ignore:line
var origDefine = global.define;
var get = function(name){
var parts = name.split("."),
cur = global,
i;
for(i = 0 ; i < parts.length; i++){
if(!cur) {
break;
}
cur = cur[parts[i]];
}
return cur;
};
var set = function(name, val){
var parts = name.split("."),
cur = global,
i, part, next;
for(i = 0; i < parts.length - 1; i++) {
part = parts[i];
next = cur[part];
if(!next) {
next = cur[part] = {};
}
cur = next;
}
part = parts[parts.length - 1];
cur[part] = val;
};
var useDefault = function(mod){
if(!mod || !mod.__esModule) return false;
var esProps = { __esModule: true, "default": true };
for(var p in mod) {
if(!esProps[p]) return false;
}
return true;
};
var modules = (global.define && global.define.modules) ||
(global._define && global._define.modules) || {};
var ourDefine = global.define = function(moduleName, deps, callback){
var module;
if(typeof deps === "function") {
callback = deps;
deps = [];
}
var args = [],
i;
for(i =0; i < deps.length; i++) {
args.push( exports[deps[i]] ? get(exports[deps[i]]) : ( modules[deps[i]] || get(deps[i]) ) );
}
// CJS has no dependencies but 3 callback arguments
if(!deps.length && callback.length) {
module = { exports: {} };
var require = function(name) {
return exports[name] ? get(exports[name]) : modules[name];
};
args.push(require, module.exports, module);
}
// Babel uses the exports and module object.
else if(!args[0] && deps[0] === "exports") {
module = { exports: {} };
args[0] = module.exports;
if(deps[1] === "module") {
args[1] = module;
}
} else if(!args[0] && deps[0] === "module") {
args[0] = { id: moduleName };
}
global.define = origDefine;
var result = callback ? callback.apply(null, args) : undefined;
global.define = ourDefine;
// Favor CJS module.exports over the return value
result = module && module.exports ? module.exports : result;
modules[moduleName] = result;
// Set global exports
var globalExport = exports[moduleName];
if(globalExport && !get(globalExport)) {
if(useDefault(result)) {
result = result["default"];
}
set(globalExport, result);
}
};
global.define.orig = origDefine;
global.define.modules = modules;
global.define.amd = true;
ourDefine("@loader", [], function(){
// shim for @@global-helpers
var noop = function(){};
return {
get: function(){
return { prepareGlobal: noop, retrieveGlobal: noop };
},
global: global,
__exec: function(__load){
doEval(__load.source, global);
}
};
});
}
)({"jquery":"jQuery","can-util/namespace":"can","kefir":"Kefir","validate.js":"validate"},window,function(__$source__, __$global__) { // jshint ignore:line
eval("(function() { " + __$source__ + " \n }).call(__$global__);");
}
)
/*can-namespace@1.0.0#can-namespace*/
define('can-namespace', function (require, exports, module) {
module.exports = {};
});
/*can-util@3.2.2#namespace*/
define('can-util/namespace', function (require, exports, module) {
module.exports = require('can-namespace');
});
/*can-util@3.2.2#js/assign/assign*/
define('can-util/js/assign/assign', function (require, exports, module) {
module.exports = function (d, s) {
for (var prop in s) {
d[prop] = s[prop];
}
return d;
};
});
/*can-util@3.2.2#js/is-array/is-array*/
define('can-util/js/is-array/is-array', function (require, exports, module) {
module.exports = function (arr) {
return Array.isArray(arr);
};
});
/*can-util@3.2.2#js/is-function/is-function*/
define('can-util/js/is-function/is-function', function (require, exports, module) {
var isFunction = function () {
if (typeof document !== 'undefined' && typeof document.getElementsByTagName('body') === 'function') {
return function (value) {
return Object.prototype.toString.call(value) === '[object Function]';
};
}
return function (value) {
return typeof value === 'function';
};
}();
module.exports = isFunction;
});
/*can-util@3.2.2#js/is-plain-object/is-plain-object*/
define('can-util/js/is-plain-object/is-plain-object', function (require, exports, module) {
var core_hasOwn = Object.prototype.hasOwnProperty;
function isWindow(obj) {
return obj !== null && obj == obj.window;
}
function isPlainObject(obj) {
if (!obj || typeof obj !== 'object' || obj.nodeType || isWindow(obj)) {
return false;
}
try {
if (obj.constructor && !core_hasOwn.call(obj, 'constructor') && !core_hasOwn.call(obj.constructor.prototype, 'isPrototypeOf')) {
return false;
}
} catch (e) {
return false;
}
var key;
for (key in obj) {
}
return key === undefined || core_hasOwn.call(obj, key);
}
module.exports = isPlainObject;
});
/*can-util@3.2.2#js/deep-assign/deep-assign*/
define('can-util/js/deep-assign/deep-assign', function (require, exports, module) {
var isArray = require('can-util/js/is-array/is-array');
var isFunction = require('can-util/js/is-function/is-function');
var isPlainObject = require('can-util/js/is-plain-object/is-plain-object');
function deepAssign() {
var options, name, src, copy, copyIsArray, clone, target = arguments[0] || {}, i = 1, length = arguments.length;
if (typeof target !== 'object' && !isFunction(target)) {
target = {};
}
if (length === i) {
target = this;
--i;
}
for (; i < length; i++) {
if ((options = arguments[i]) != null) {
for (name in options) {
src = target[name];
copy = options[name];
if (target === copy) {
continue;
}
if (copy && (isPlainObject(copy) || (copyIsArray = isArray(copy)))) {
if (copyIsArray) {
copyIsArray = false;
clone = src && isArray(src) ? src : [];
} else {
clone = src && isPlainObject(src) ? src : {};
}
target[name] = deepAssign(clone, copy);
} else if (copy !== undefined) {
target[name] = copy;
}
}
}
}
return target;
}
module.exports = deepAssign;
});
/*can-util@3.2.2#js/log/log*/
define('can-util/js/log/log', function (require, exports, module) {
exports.warnTimeout = 5000;
exports.logLevel = 0;
exports.warn = function (out) {
var ll = this.logLevel;
if (ll < 2) {
Array.prototype.unshift.call(arguments, 'WARN:');
if (typeof console !== 'undefined' && console.warn) {
this._logger('warn', Array.prototype.slice.call(arguments));
} else if (typeof console !== 'undefined' && console.log) {
this._logger('log', Array.prototype.slice.call(arguments));
} else if (window && window.opera && window.opera.postError) {
window.opera.postError('CanJS WARNING: ' + out);
}
}
};
exports.log = function (out) {
var ll = this.logLevel;
if (ll < 1) {
if (typeof console !== 'undefined' && console.log) {
Array.prototype.unshift.call(arguments, 'INFO:');
this._logger('log', Array.prototype.slice.call(arguments));
} else if (window && window.opera && window.opera.postError) {
window.opera.postError('CanJS INFO: ' + out);
}
}
};
exports.error = function (out) {
var ll = this.logLevel;
if (ll < 1) {
if (typeof console !== 'undefined' && console.error) {
Array.prototype.unshift.call(arguments, 'ERROR:');
this._logger('error', Array.prototype.slice.call(arguments));
} else if (window && window.opera && window.opera.postError) {
window.opera.postError('ERROR: ' + out);
}
}
};
exports._logger = function (type, arr) {
try {
console[type].apply(console, arr);
} catch (e) {
console[type](arr);
}
};
});
/*can-util@3.2.2#js/dev/dev*/
define('can-util/js/dev/dev', function (require, exports, module) {
var canLog = require('can-util/js/log/log');
module.exports = {
warnTimeout: 5000,
logLevel: 0,
warn: function () {
canLog.warn.apply(this, arguments);
},
log: function () {
canLog.log.apply(this, arguments);
},
_logger: canLog._logger
};
});
/*can-util@3.2.2#js/is-array-like/is-array-like*/
define('can-util/js/is-array-like/is-array-like', function (require, exports, module) {
function isArrayLike(obj) {
var type = typeof obj;
if (type === 'string') {
return true;
}
var length = obj && type !== 'boolean' && typeof obj !== 'number' && 'length' in obj && obj.length;
return typeof arr !== 'function' && (length === 0 || typeof length === 'number' && length > 0 && length - 1 in obj);
}
module.exports = isArrayLike;
});
/*can-types@1.0.2#can-types*/
define('can-types', function (require, exports, module) {
var namespace = require('can-namespace');
var types = {
isMapLike: function () {
return false;
},
isListLike: function () {
return false;
},
isPromise: function (obj) {
return obj instanceof Promise || Object.prototype.toString.call(obj) === '[object Promise]';
},
isConstructor: function (func) {
if (typeof func !== 'function') {
return false;
}
for (var prop in func.prototype) {
return true;
}
return false;
},
isCallableForValue: function (obj) {
return typeof obj === 'function' && !types.isConstructor(obj);
},
isCompute: function (obj) {
return obj && obj.isComputed;
},
iterator: typeof Symbol === 'function' && Symbol.iterator || '@@iterator',
DefaultMap: null,
DefaultList: null,
queueTask: function (task) {
var args = task[2] || [];
task[0].apply(task[1], args);
},
wrapElement: function (element) {
return element;
},
unwrapElement: function (element) {
return element;
}
};
if (namespace.types) {
throw new Error('You can\'t have two versions of can-types, check your dependencies');
} else {
module.exports = namespace.types = types;
}
});
/*can-util@3.2.2#js/is-iterable/is-iterable*/
define('can-util/js/is-iterable/is-iterable', function (require, exports, module) {
var types = require('can-types');
module.exports = function (obj) {
return obj && !!obj[types.iterator];
};
});
/*can-util@3.2.2#js/each/each*/
define('can-util/js/each/each', function (require, exports, module) {
var isArrayLike = require('can-util/js/is-array-like/is-array-like');
var has = Object.prototype.hasOwnProperty;
var isIterable = require('can-util/js/is-iterable/is-iterable');
var types = require('can-types');
function each(elements, callback, context) {
var i = 0, key, len, item;
if (elements) {
if (isArrayLike(elements)) {
for (len = elements.length; i < len; i++) {
item = elements[i];
if (callback.call(context || item, item, i, elements) === false) {
break;
}
}
} else if (isIterable(elements)) {
var iter = elements[types.iterator]();
var res, value;
while (!(res = iter.next()).done) {
value = res.value;
callback.call(context || elements, Array.isArray(value) ? value[1] : value, value[0]);
}
} else if (typeof elements === 'object') {
for (key in elements) {
if (has.call(elements, key) && callback.call(context || elements[key], elements[key], key, elements) === false) {
break;
}
}
}
}
return elements;
}
module.exports = each;
});
/*can-util@3.2.2#js/make-array/make-array*/
define('can-util/js/make-array/make-array', function (require, exports, module) {
var each = require('can-util/js/each/each');
function makeArray(arr) {
var ret = [];
each(arr, function (a, i) {
ret[i] = a;
});
return ret;
}
module.exports = makeArray;
});
/*can-util@3.2.2#js/is-container/is-container*/
define('can-util/js/is-container/is-container', function (require, exports, module) {
module.exports = function (current) {
return /^f|^o/.test(typeof current);
};
});
/*can-util@3.2.2#js/get/get*/
define('can-util/js/get/get', function (require, exports, module) {
var isContainer = require('can-util/js/is-container/is-container');
function get(obj, name) {
var parts = typeof name !== 'undefined' ? (name + '').replace(/\[/g, '.').replace(/]/g, '').split('.') : [], length = parts.length, current, i, container;
if (!length) {
return obj;
}
current = obj;
for (i = 0; i < length && isContainer(current); i++) {
container = current;
current = container[parts[i]];
}
return current;
}
module.exports = get;
});
/*can-util@3.2.2#js/string/string*/
define('can-util/js/string/string', function (require, exports, module) {
var get = require('can-util/js/get/get');
var isContainer = require('can-util/js/is-container/is-container');
var canDev = require('can-util/js/dev/dev');
var isArray = require('can-util/js/is-array/is-array');
var strUndHash = /_|-/, strColons = /\=\=/, strWords = /([A-Z]+)([A-Z][a-z])/g, strLowUp = /([a-z\d])([A-Z])/g, strDash = /([a-z\d])([A-Z])/g, strReplacer = /\{([^\}]+)\}/g, strQuote = /"/g, strSingleQuote = /'/g, strHyphenMatch = /-+(.)?/g, strCamelMatch = /[a-z][A-Z]/g, convertBadValues = function (content) {
var isInvalid = content === null || content === undefined || isNaN(content) && '' + content === 'NaN';
return '' + (isInvalid ? '' : content);
}, deleteAtPath = function (data, path) {
var parts = path ? path.replace(/\[/g, '.').replace(/]/g, '').split('.') : [];
var current = data;
for (var i = 0; i < parts.length - 1; i++) {
if (current) {
current = current[parts[i]];
}
}
if (current) {
delete current[parts[parts.length - 1]];
}
};
var string = {
esc: function (content) {
return convertBadValues(content).replace(/&/g, '&').replace(/</g, '<').replace(/>/g, '>').replace(strQuote, '"').replace(strSingleQuote, ''');
},
getObject: function (name, roots) {
canDev.warn('string.getObject is deprecated, please use can-util/js/get/get instead.');
roots = isArray(roots) ? roots : [roots || window];
var result, l = roots.length;
for (var i = 0; i < l; i++) {
result = get(roots[i], name);
if (result) {
return result;
}
}
},
capitalize: function (s, cache) {
return s.charAt(0).toUpperCase() + s.slice(1);
},
camelize: function (str) {
return convertBadValues(str).replace(strHyphenMatch, function (match, chr) {
return chr ? chr.toUpperCase() : '';
});
},
hyphenate: function (str) {
return convertBadValues(str).replace(strCamelMatch, function (str, offset) {
return str.charAt(0) + '-' + str.charAt(1).toLowerCase();
});
},
underscore: function (s) {
return s.replace(strColons, '/').replace(strWords, '$1_$2').replace(strLowUp, '$1_$2').replace(strDash, '_').toLowerCase();
},
sub: function (str, data, remove) {
var obs = [];
str = str || '';
obs.push(str.replace(strReplacer, function (whole, inside) {
var ob = get(data, inside);
if (remove === true) {
deleteAtPath(data, inside);
}
if (ob === undefined || ob === null) {
obs = null;
return '';
}
if (isContainer(ob) && obs) {
obs.push(ob);
return '';
}
return '' + ob;
}));
return obs === null ? obs : obs.length <= 1 ? obs[0] : obs;
},
replacer: strReplacer,
undHash: strUndHash
};
module.exports = string;
});
/*can-construct@3.0.6#can-construct*/
define('can-construct', function (require, exports, module) {
'use strict';
var assign = require('can-util/js/assign/assign');
var deepAssign = require('can-util/js/deep-assign/deep-assign');
var dev = require('can-util/js/dev/dev');
var makeArray = require('can-util/js/make-array/make-array');
var types = require('can-types');
var namespace = require('can-namespace');
var CanString = require('can-util/js/string/string');
var reservedWords = {
'abstract': true,
'boolean': true,
'break': true,
'byte': true,
'case': true,
'catch': true,
'char': true,
'class': true,
'const': true,
'continue': true,
'debugger': true,
'default': true,
'delete': true,
'do': true,
'double': true,
'else': true,
'enum': true,
'export': true,
'extends': true,
'false': true,
'final': true,
'finally': true,
'float': true,
'for': true,
'function': true,
'goto': true,
'if': true,
'implements': true,
'import': true,
'in': true,
'instanceof': true,
'int': true,
'interface': true,
'let': true,
'long': true,
'native': true,
'new': true,
'null': true,
'package': true,
'private': true,
'protected': true,
'public': true,
'return': true,
'short': true,
'static': true,
'super': true,
'switch': true,
'synchronized': true,
'this': true,
'throw': true,
'throws': true,
'transient': true,
'true': true,
'try': true,
'typeof': true,
'var': true,
'void': true,
'volatile': true,
'while': true,
'with': true
};
var constructorNameRegex = /[^A-Z0-9_]/gi;
var initializing = 0;
var namedCtor = function (cache) {
return function (name, fn) {
return (name in cache ? cache[name] : cache[name] = new Function('__', 'function ' + name + '(){return __.apply(this,arguments)};return ' + name))(fn);
};
}({});
var Construct = function () {
if (arguments.length) {
return Construct.extend.apply(Construct, arguments);
}
};
var canGetDescriptor;
try {
Object.getOwnPropertyDescriptor({});
canGetDescriptor = true;
} catch (e) {
canGetDescriptor = false;
}
var getDescriptor = function (newProps, name) {
var descriptor = Object.getOwnPropertyDescriptor(newProps, name);
if (descriptor && (descriptor.get || descriptor.set)) {
return descriptor;
}
return null;
}, inheritGetterSetter = function (newProps, oldProps, addTo) {
addTo = addTo || newProps;
var descriptor;
for (var name in newProps) {
if (descriptor = getDescriptor(newProps, name)) {
this._defineProperty(addTo, oldProps, name, descriptor);
} else {
Construct._overwrite(addTo, oldProps, name, newProps[name]);
}
}
}, simpleInherit = function (newProps, oldProps, addTo) {
addTo = addTo || newProps;
for (var name in newProps) {
Construct._overwrite(addTo, oldProps, name, newProps[name]);
}
};
assign(Construct, {
constructorExtends: true,
newInstance: function () {
var inst = this.instance(), args;
if (inst.setup) {
Object.defineProperty(inst, '__inSetup', {
configurable: true,
enumerable: false,
value: true,
writable: true
});
args = inst.setup.apply(inst, arguments);
inst.__inSetup = false;
}
if (inst.init) {
inst.init.apply(inst, args || arguments);
}
return inst;
},
_inherit: canGetDescriptor ? inheritGetterSetter : simpleInherit,
_defineProperty: function (what, oldProps, propName, descriptor) {
Object.defineProperty(what, propName, descriptor);
},
_overwrite: function (what, oldProps, propName, val) {
Object.defineProperty(what, propName, {
value: val,
configurable: true,
enumerable: true,
writable: true
});
},
setup: function (base) {
this.defaults = deepAssign(true, {}, base.defaults, this.defaults);
},
instance: function () {
initializing = 1;
var inst = new this();
initializing = 0;
return inst;
},
extend: function (name, staticProperties, instanceProperties) {
var shortName = name, klass = staticProperties, proto = instanceProperties;
if (typeof shortName !== 'string') {
proto = klass;
klass = shortName;
shortName = null;
}
if (!proto) {
proto = klass;
klass = null;
}
proto = proto || {};
var _super_class = this, _super = this.prototype, Constructor, prototype;
prototype = this.instance();
Construct._inherit(proto, _super, prototype);
if (shortName) {
} else if (klass && klass.shortName) {
shortName = klass.shortName;
} else if (this.shortName) {
shortName = this.shortName;
}
var constructorName = shortName ? shortName.replace(constructorNameRegex, '_') : 'Constructor';
if (reservedWords[constructorName]) {
constructorName = CanString.capitalize(constructorName);
}
function init() {
if (!initializing) {
if (!this || this.constructor !== Constructor && arguments.length && Constructor.constructorExtends) {
dev.warn('can/construct/construct.js: extending a Construct without calling extend');
}
return (!this || this.constructor !== Constructor) && arguments.length && Constructor.constructorExtends ? Constructor.extend.apply(Constructor, arguments) : Constructor.newInstance.apply(Constructor, arguments);
}
}
Constructor = typeof namedCtor === 'function' ? namedCtor(constructorName, init) : function () {
return init.apply(this, arguments);
};
for (var propName in _super_class) {
if (_super_class.hasOwnProperty(propName)) {
Constructor[propName] = _super_class[propName];
}
}
Construct._inherit(klass, _super_class, Constructor);
assign(Constructor, {
constructor: Constructor,
prototype: prototype
});
if (shortName !== undefined) {
Constructor.shortName = shortName;
}
Constructor.prototype.constructor = Constructor;
var t = [_super_class].concat(makeArray(arguments)), args = Constructor.setup.apply(Constructor, t);
if (Constructor.init) {
Constructor.init.apply(Constructor, args || t);
}
return Constructor;
}
});
Construct.prototype.setup = function () {
};
Construct.prototype.init = function () {
};
var oldIsConstructor = types.isConstructor;
types.isConstructor = function (obj) {
return obj.prototype instanceof Construct || oldIsConstructor.call(null, obj);
};
module.exports = namespace.Construct = Construct;
});
/*can-util@3.2.2#js/is-empty-object/is-empty-object*/
define('can-util/js/is-empty-object/is-empty-object', function (require, exports, module) {
module.exports = function (obj) {
for (var prop in obj) {
return false;
}
return true;
};
});
/*can-util@3.2.2#dom/data/data*/
define('can-util/dom/data/data', function (require, exports, module) {
var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
var data = {};
var expando = 'can' + new Date();
var uuid = 0;
var setData = function (name, value) {
var id = this[expando] || (this[expando] = ++uuid), store = data[id] || (data[id] = {});
if (name !== undefined) {
store[name] = value;
}
return store;
};
module.exports = {
getCid: function () {
return this[expando];
},
cid: function () {
return this[expando] || (this[expando] = ++uuid);
},
expando: expando,
clean: function (prop) {
var id = this[expando];
if (data[id] && data[id][prop]) {
delete data[id][prop];
}
if (isEmptyObject(data[id])) {
delete data[id];
}
},
get: function (key) {
var id = this[expando], store = id && data[id];
return key === undefined ? store || setData(this) : store && store[key];
},
set: setData
};
});
/*can-util@3.2.2#dom/class-name/class-name*/
define('can-util/dom/class-name/class-name', function (require, exports, module) {
var has = function (className) {
if (this.classList) {
return this.classList.contains(className);
} else {
return !!this.className.match(new RegExp('(\\s|^)' + className + '(\\s|$)'));
}
};
module.exports = {
has: has,
add: function (className) {
if (this.classList) {
this.classList.add(className);
} else if (!has.call(this, className)) {
this.className += ' ' + className;
}
},
remove: function (className) {
if (this.classList) {
this.classList.remove(className);
} else if (has.call(this, className)) {
var reg = new RegExp('(\\s|^)' + className + '(\\s|$)');
this.className = this.className.replace(reg, ' ');
}
}
};
});
/*can-util@3.2.2#js/global/global*/
define('can-util/js/global/global', function (require, exports, module) {
(function (global) {
var GLOBAL;
module.exports = function (setGlobal) {
if (setGlobal !== undefined) {
GLOBAL = setGlobal;
}
if (GLOBAL) {
return GLOBAL;
} else {
return GLOBAL = typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self : typeof process === 'object' && {}.toString.call(process) === '[object process]' ? global : window;
}
};
}(function () {
return this;
}()));
});
/*can-util@3.2.2#dom/document/document*/
define('can-util/dom/document/document', function (require, exports, module) {
(function (global) {
var global = require('can-util/js/global/global');
var setDocument;
module.exports = function (setDoc) {
if (setDoc) {
setDocument = setDoc;
}
return setDocument || global().document;
};
}(function () {
return this;
}()));
});
/*can-util@3.2.2#dom/events/events*/
define('can-util/dom/events/events', function (require, exports, module) {
var assign = require('can-util/js/assign/assign');
var _document = require('can-util/dom/document/document');
module.exports = {
addEventListener: function () {
this.addEventListener.apply(this, arguments);
},
removeEventListener: function () {
this.removeEventListener.apply(this, arguments);
},
canAddEventListener: function () {
return this.nodeName && (this.nodeType === 1 || this.nodeType === 9) || this === window;
},
dispatch: function (event, args, bubbles) {
var doc = _document();
var ev = doc.createEvent('HTMLEvents');
var isString = typeof event === 'string';
ev.initEvent(isString ? event : event.type, bubbles === undefined ? true : bubbles, false);
if (!isString) {
assign(ev, event);
}
ev.args = args;
return this.dispatchEvent(ev);
}
};
});
/*can-cid@1.0.1#can-cid*/
define('can-cid', function (require, exports, module) {
var namespace = require('can-namespace');
var _cid = 0;
var cid = function (object, name) {
if (!object._cid) {
_cid++;
object._cid = (name || '') + _cid;
}
return object._cid;
};
if (namespace.cid) {
throw new Error('You can\'t have two versions of can-cid, check your dependencies');
} else {
module.exports = namespace.cid = cid;
}
});
/*can-util@3.2.2#dom/dispatch/dispatch*/
define('can-util/dom/dispatch/dispatch', function (require, exports, module) {
var domEvents = require('can-util/dom/events/events');
module.exports = function () {
return domEvents.dispatch.apply(this, arguments);
};
});
/*can-util@3.2.2#dom/matches/matches*/
define('can-util/dom/matches/matches', function (require, exports, module) {
var matchesMethod = function (element) {
return element.matches || element.webkitMatchesSelector || element.webkitMatchesSelector || element.mozMatchesSelector || element.msMatchesSelector || element.oMatchesSelector;
};
module.exports = function () {
var method = matchesMethod(this);
return method ? method.apply(this, arguments) : false;
};
});
/*can-util@3.2.2#dom/events/delegate/delegate*/
define('can-util/dom/events/delegate/delegate', function (require, exports, module) {
var domEvents = require('can-util/dom/events/events');
var domData = require('can-util/dom/data/data');
var domMatches = require('can-util/dom/matches/matches');
var each = require('can-util/js/each/each');
var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
var dataName = 'delegateEvents';
var useCapture = function (eventType) {
return eventType === 'focus' || eventType === 'blur';
};
var handleEvent = function (ev) {
var events = domData.get.call(this, dataName);
var eventTypeEvents = events[ev.type];
var matches = [];
if (eventTypeEvents) {
var selectorDelegates = [];
each(eventTypeEvents, function (delegates) {
selectorDelegates.push(delegates);
});
var cur = ev.target;
do {
selectorDelegates.forEach(function (delegates) {
if (domMatches.call(cur, delegates[0].selector)) {
matches.push({
target: cur,
delegates: delegates
});
}
});
cur = cur.parentNode;
} while (cur && cur !== ev.currentTarget);
}
var oldStopProp = ev.stopPropagation;
ev.stopPropagation = function () {
oldStopProp.apply(this, arguments);
this.cancelBubble = true;
};
for (var i = 0; i < matches.length; i++) {
var match = matches[i];
var delegates = match.delegates;
for (var d = 0, dLen = delegates.length; d < dLen; d++) {
if (delegates[d].handler.call(match.target, ev) === false) {
return false;
}
if (ev.cancelBubble) {
return;
}
}
}
};
domEvents.addDelegateListener = function (eventType, selector, handler) {
var events = domData.get.call(this, dataName), eventTypeEvents;
if (!events) {
domData.set.call(this, dataName, events = {});
}
if (!(eventTypeEvents = events[eventType])) {
eventTypeEvents = events[eventType] = {};
domEvents.addEventListener.call(this, eventType, handleEvent, useCapture(eventType));
}
if (!eventTypeEvents[selector]) {
eventTypeEvents[selector] = [];
}
eventTypeEvents[selector].push({
handler: handler,
selector: selector
});
};
domEvents.removeDelegateListener = function (eventType, selector, handler) {
var events = domData.get.call(this, dataName);
if (events[eventType] && events[eventType][selector]) {
var eventTypeEvents = events[eventType], delegates = eventTypeEvents[selector], i = 0;
while (i < delegates.length) {
if (delegates[i].handler === handler) {
delegates.splice(i, 1);
} else {
i++;
}
}
if (delegates.length === 0) {
delete eventTypeEvents[selector];
if (isEmptyObject(eventTypeEvents)) {
domEvents.removeEventListener.call(this, eventType, handleEvent, useCapture(eventType));
delete events[eventType];
if (isEmptyObject(events)) {
domData.clean.call(this, dataName);
}
}
}
}
};
});
/*can-event@3.0.2#can-event*/
define('can-event', function (require, exports, module) {
var domEvents = require('can-util/dom/events/events');
var CID = require('can-cid');
var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
var domDispatch = require('can-util/dom/dispatch/dispatch');
var namespace = require('can-namespace');
require('can-util/dom/events/delegate/delegate');
function makeHandlerArgs(event, args) {
if (typeof event === 'string') {
event = { type: event };
}
var handlerArgs = [event];
if (args) {
handlerArgs.push.apply(handlerArgs, args);
}
return handlerArgs;
}
function getHandlers(eventName) {
var events = this.__bindEvents;
if (!events) {
return;
}
var handlers = events[eventName];
if (!handlers) {
return;
} else {
return handlers;
}
}
var canEvent = {
addEventListener: function (event, handler) {
var allEvents = this.__bindEvents || (this.__bindEvents = {}), eventList = allEvents[event] || (allEvents[event] = []);
eventList.push(handler);
return this;
},
removeEventListener: function (event, fn) {
if (!this.__bindEvents) {
return this;
}
var handlers = this.__bindEvents[event] || [], i = 0, handler, isFunction = typeof fn === 'function';
while (i < handlers.length) {
handler = handlers[i];
if (isFunction && handler === fn || !isFunction && (handler.cid === fn || !fn)) {
handlers.splice(i, 1);
} else {
i++;
}
}
return this;
},
dispatchSync: function (event, args) {
var handlerArgs = makeHandlerArgs(event, args);
var handlers = getHandlers.call(this, handlerArgs[0].type);
if (!handlers) {
return;
}
handlers = handlers.slice(0);
for (var i = 0, len = handlers.length; i < len; i++) {
handlers[i].apply(this, handlerArgs);
}
return handlerArgs[0];
},
on: function (eventName, selector, handler) {
var method = typeof selector === 'string' ? 'addDelegateListener' : 'addEventListener';
var listenWithDOM = domEvents.canAddEventListener.call(this);
var eventBinder = listenWithDOM ? domEvents[method] : this[method] || canEvent[method];
return eventBinder.apply(this, arguments);
},
off: function (eventName, selector, handler) {
var method = typeof selector === 'string' ? 'removeDelegateListener' : 'removeEventListener';
var listenWithDOM = domEvents.canAddEventListener.call(this);
var eventBinder = listenWithDOM ? domEvents[method] : this[method] || canEvent[method];
return eventBinder.apply(this, arguments);
},
trigger: function () {
var listenWithDOM = domEvents.canAddEventListener.call(this);
var dispatch = listenWithDOM ? domDispatch : canEvent.dispatch;
return dispatch.apply(this, arguments);
},
one: function (event, handler) {
var one = function () {
canEvent.off.call(this, event, one);
return handler.apply(this, arguments);
};
canEvent.on.call(this, event, one);
return this;
},
listenTo: function (other, event, handler) {
var idedEvents = this.__listenToEvents;
if (!idedEvents) {
idedEvents = this.__listenToEvents = {};
}
var otherId = CID(other);
var othersEvents = idedEvents[otherId];
if (!othersEvents) {
othersEvents = idedEvents[otherId] = {
obj: other,
events: {}
};
}
var eventsEvents = othersEvents.events[event];
if (!eventsEvents) {
eventsEvents = othersEvents.events[event] = [];
}
eventsEvents.push(handler);
canEvent.on.call(other, event, handler);
},
stopListening: function (other, event, handler) {
var idedEvents = this.__listenToEvents, iterIdedEvents = idedEvents, i = 0;
if (!idedEvents) {
return this;
}
if (other) {
var othercid = CID(other);
(iterIdedEvents = {})[othercid] = idedEvents[othercid];
if (!idedEvents[othercid]) {
return this;
}
}
for (var cid in iterIdedEvents) {
var othersEvents = iterIdedEvents[cid], eventsEvents;
other = idedEvents[cid].obj;
if (!event) {
eventsEvents = othersEvents.events;
} else {
(eventsEvents = {})[event] = othersEvents.events[event];
}
for (var eventName in eventsEvents) {
var handlers = eventsEvents[eventName] || [];
i = 0;
while (i < handlers.length) {
if (handler && handler === handlers[i] || !handler) {
canEvent.off.call(other, eventName, handlers[i]);
handlers.splice(i, 1);
} else {
i++;
}
}
if (!handlers.length) {
delete othersEvents.events[eventName];
}
}
if (isEmptyObject(othersEvents.events)) {
delete idedEvents[cid];
}
}
return this;
}
};
canEvent.addEvent = canEvent.bind = function () {
return canEvent.addEventListener.apply(this, arguments);
};
canEvent.unbind = canEvent.removeEvent = function () {
return canEvent.removeEventListener.apply(this, arguments);
};
canEvent.delegate = canEvent.on;
canEvent.undelegate = canEvent.off;
canEvent.dispatch = canEvent.dispatchSync;
Object.defineProperty(canEvent, 'makeHandlerArgs', {
enumerable: false,
value: makeHandlerArgs
});
Object.defineProperty(canEvent, 'handlers', {
enumerable: false,
value: getHandlers
});
Object.defineProperty(canEvent, 'flush', {
enumerable: false,
writable: true,
value: function () {
}
});
module.exports = namespace.event = canEvent;
});
/*can-util@3.2.2#js/last/last*/
define('can-util/js/last/last', function (require, exports, module) {
module.exports = function (arr) {
return arr && arr[arr.length - 1];
};
});
/*can-event@3.0.2#batch/batch*/
define('can-event/batch/batch', function (require, exports, module) {
'use strict';
var canEvent = require('can-event');
var last = require('can-util/js/last/last');
var namespace = require('can-namespace');
var canTypes = require('can-types');
var canDev = require('can-util/js/dev/dev');
var group = console.group && console.group.bind(console) || console.log;
var groupEnd = console.groupEnd && console.groupEnd.bind(console) || function () {
};
var batchNum = 1, collectionQueue = null, queues = [], dispatchingQueues = false, makeHandlerArgs = canEvent.makeHandlerArgs, getHandlers = canEvent.handlers;
function addToCollectionQueue(item, event, args, handlers) {
var handlerArgs = makeHandlerArgs(event, args);
var tasks = [];
for (var i = 0, len = handlers.length; i < len; i++) {
tasks[i] = [
handlers[i],
item,
handlerArgs
];
}
[].push.apply(collectionQueue.tasks, tasks);
}
var canBatch = {
transactions: 0,
start: function (batchStopHandler) {
canBatch.transactions++;
if (canBatch.transactions === 1) {
var queue = {
number: batchNum++,
index: 0,
tasks: [],
batchEnded: false,
callbacksIndex: 0,
callbacks: [],
complete: false
};
if (batchStopHandler) {
queue.callbacks.push(batchStopHandler);
}
collectionQueue = queue;
}
},
collecting: function () {
return collectionQueue;
},
dispatching: function () {
return queues[0];
},
stop: function (force, callStart) {
if (force) {
canBatch.transactions = 0;
} else {
canBatch.transactions--;
}
if (canBatch.transactions === 0) {
queues.push(collectionQueue);
collectionQueue = null;
if (!dispatchingQueues) {
canEvent.flush();
}
}
},
flush: function () {
var debug = canDev.logLevel >= 1;
dispatchingQueues = true;
while (queues.length) {
var queue = queues[0];
var tasks = queue.tasks, callbacks = queue.callbacks;
canBatch.batchNum = queue.number;
var len = tasks.length, index;
if (debug && queue.index === 0 && queue.index < len) {
group('batch running ' + queue.number);
}
while (queue.index < len) {
index = queue.index++;
if (debug) {
var context = tasks[index][1];
var args = tasks[index][2];
if (args && args[0]) {
console.log('dispatching', args[0].type, 'on', context);
}
}
tasks[index][0].apply(tasks[index][1], tasks[index][2]);
}
if (!queue.batchEnded) {
if (debug) {
console.log('tasks ended');
}
queue.batchEnded = true;
canEvent.dispatchSync.call(canBatch, 'batchEnd', [queue.number]);
}
if (debug && queue.callbacksIndex < callbacks.length) {
console.log('calling callbacks');
}
while (queue.callbacksIndex < callbacks.length) {
callbacks[queue.callbacksIndex++]();
}
if (!queue.complete) {
queue.complete = true;
canBatch.batchNum = undefined;
queues.shift();
if (debug) {
groupEnd();
}
}
}
dispatchingQueues = false;
},
dispatch: function (event, args) {
var item = this, handlers;
if (!item.__inSetup) {
event = typeof event === 'string' ? { type: event } : event;
if (event.batchNum) {
canEvent.dispatchSync.call(item, event, args);
} else if (collectionQueue) {
handlers = getHandlers.call(this, event.type);
if (handlers) {
event.batchNum = collectionQueue.number;
addToCollectionQueue(item, event, args, handlers);
}
} else if (queues.length) {
handlers = getHandlers.call(this, event.type);
if (handlers) {
canBatch.start();
event.batchNum = collectionQueue.number;
addToCollectionQueue(item, event, args, handlers);
last(queues).callbacks.push(canBatch.stop);
}
} else {
handlers = getHandlers.call(this, event.type);
if (handlers) {
canBatch.start();
event.batchNum = collectionQueue.number;
addToCollectionQueue(item, event, args, handlers);
canBatch.stop();
}
}
}
},
queue: function (task, inCurrentBatch) {
if (collectionQueue) {
collectionQueue.tasks.push(task);
} else if (queues.length) {
if (inCurrentBatch && queues[0].index < queues.tasks.length) {
queues[0].tasks.push(task);
} else {
canBatch.start();
collectionQueue.tasks.push(task);
last(queues).callbacks.push(canBatch.stop);
}
} else {
canBatch.start();
collectionQueue.tasks.push(task);
canBatch.stop();
}
},
queues: function () {
return queues;
},
afterPreviousEvents: function (handler) {
this.queue([handler]);
},
after: function (handler) {
var queue = collectionQueue || queues[0];
if (queue) {
queue.callbacks.push(handler);
} else {
handler({});
}
}
};
canEvent.flush = canBatch.flush;
canEvent.dispatch = canBatch.dispatch;
canBatch.trigger = function () {
console.warn('use canEvent.dispatch instead');
return canEvent.dispatch.apply(this, arguments);
};
canTypes.queueTask = canBatch.queue;
module.exports = namespace.batch = canBatch;
});
/*can-observation@3.0.6#can-observation*/
define('can-observation', function (require, exports, module) {
require('can-event');
var canEvent = require('can-event');
var canBatch = require('can-event/batch/batch');
var assign = require('can-util/js/assign/assign');
var namespa