can
Version:
MIT-licensed, client-side, JavaScript framework that makes building rich web applications easy.
1,321 lines (1,316 loc) • 902 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.7.0#namespace*/
define('can-util/namespace', function (require, exports, module) {
module.exports = require('can-namespace');
});
/*can-util@3.7.0#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.7.0#js/is-array/is-array*/
define('can-util/js/is-array/is-array', function (require, exports, module) {
'use strict';
module.exports = function (arr) {
return Array.isArray(arr);
};
});
/*can-util@3.7.0#js/is-function/is-function*/
define('can-util/js/is-function/is-function', function (require, exports, module) {
'use strict';
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.7.0#js/is-plain-object/is-plain-object*/
define('can-util/js/is-plain-object/is-plain-object', function (require, exports, module) {
'use strict';
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.7.0#js/deep-assign/deep-assign*/
define('can-util/js/deep-assign/deep-assign', function (require, exports, module) {
'use strict';
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.7.0#js/log/log*/
define('can-util/js/log/log', function (require, exports, module) {
'use strict';
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.7.0#js/dev/dev*/
define('can-util/js/dev/dev', function (require, exports, module) {
'use strict';
var canLog = require('can-util/js/log/log');
module.exports = {
warnTimeout: 5000,
logLevel: 0,
stringify: function (value) {
var flagUndefined = function flagUndefined(key, value) {
return value === undefined ? '/* void(undefined) */' : value;
};
return JSON.stringify(value, flagUndefined, ' ').replace(/"\/\* void\(undefined\) \*\/"/g, 'undefined');
},
warn: function () {
canLog.warn.apply(this, arguments);
},
log: function () {
canLog.log.apply(this, arguments);
},
error: function () {
canLog.error.apply(this, arguments);
},
_logger: canLog._logger
};
});
/*can-util@3.7.0#js/is-array-like/is-array-like*/
define('can-util/js/is-array-like/is-array-like', function (require, exports, module) {
'use strict';
function isArrayLike(obj) {
var type = typeof obj;
if (type === 'string') {
return true;
} else if (type === 'number') {
return false;
}
var length = obj && type !== 'boolean' && typeof obj !== 'number' && 'length' in obj && obj.length;
return typeof obj !== 'function' && (length === 0 || typeof length === 'number' && length > 0 && length - 1 in obj);
}
module.exports = isArrayLike;
});
/*can-types@1.0.4#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.7.0#js/is-iterable/is-iterable*/
define('can-util/js/is-iterable/is-iterable', function (require, exports, module) {
'use strict';
var types = require('can-types');
module.exports = function (obj) {
return obj && !!obj[types.iterator];
};
});
/*can-util@3.7.0#js/each/each*/
define('can-util/js/each/each', function (require, exports, module) {
'use strict';
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.7.0#js/make-array/make-array*/
define('can-util/js/make-array/make-array', function (require, exports, module) {
'use strict';
var each = require('can-util/js/each/each');
var isArrayLike = require('can-util/js/is-array-like/is-array-like');
function makeArray(element) {
var ret = [];
if (isArrayLike(element)) {
each(element, function (a, i) {
ret[i] = a;
});
} else if (element === 0 || element) {
ret.push(element);
}
return ret;
}
module.exports = makeArray;
});
/*can-util@3.7.0#js/is-container/is-container*/
define('can-util/js/is-container/is-container', function (require, exports, module) {
'use strict';
module.exports = function (current) {
return /^f|^o/.test(typeof current);
};
});
/*can-util@3.7.0#js/get/get*/
define('can-util/js/get/get', function (require, exports, module) {
'use strict';
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.7.0#js/string/string*/
define('can-util/js/string/string', function (require, exports, module) {
'use strict';
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.1.1#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);
if (args instanceof Construct.ReturnValue) {
return args.value;
}
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;
},
ReturnValue: function (value) {
this.value = value;
}
});
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.7.0#js/is-empty-object/is-empty-object*/
define('can-util/js/is-empty-object/is-empty-object', function (require, exports, module) {
'use strict';
module.exports = function (obj) {
for (var prop in obj) {
return false;
}
return true;
};
});
/*can-util@3.7.0#dom/data/core*/
define('can-util/dom/data/core', function (require, exports, module) {
'use strict';
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], newStore = false;
if (!data[id]) {
newStore = true;
store = data[id] = {};
}
if (name !== undefined) {
store[name] = value;
}
return newStore;
};
var deleteNode = function () {
var id = this[expando];
var nodeDeleted = false;
if (id && data[id]) {
nodeDeleted = true;
delete data[id];
}
return nodeDeleted;
};
module.exports = {
_data: data,
getCid: function () {
return this[expando];
},
cid: function () {
return this[expando] || (this[expando] = ++uuid);
},
expando: expando,
get: function (key) {
var id = this[expando], store = id && data[id];
return key === undefined ? store || setData(this) : store && store[key];
},
set: setData,
clean: function (prop) {
var id = this[expando];
var itemData = data[id];
if (itemData && itemData[prop]) {
delete itemData[prop];
}
if (isEmptyObject(itemData)) {
deleteNode.call(this);
}
},
delete: deleteNode
};
});
/*can-util@3.7.0#js/global/global*/
define('can-util/js/global/global', function (require, exports, module) {
(function (global) {
'use strict';
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.7.0#dom/document/document*/
define('can-util/dom/document/document', function (require, exports, module) {
(function (global) {
'use strict';
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.7.0#dom/mutation-observer/mutation-observer*/
define('can-util/dom/mutation-observer/mutation-observer', function (require, exports, module) {
(function (global) {
'use strict';
var global = require('can-util/js/global/global')();
var setMutationObserver;
module.exports = function (setMO) {
if (setMO !== undefined) {
setMutationObserver = setMO;
}
return setMutationObserver !== undefined ? setMutationObserver : global.MutationObserver || global.WebKitMutationObserver || global.MozMutationObserver;
};
}(function () {
return this;
}()));
});
/*can-cid@1.0.3#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.7.0#js/cid/get-cid*/
define('can-util/js/cid/get-cid', function (require, exports, module) {
'use strict';
var CID = require('can-cid');
var domDataCore = require('can-util/dom/data/core');
module.exports = function (obj) {
if (typeof obj.nodeType === 'number') {
return domDataCore.cid.call(obj);
} else {
var type = typeof obj;
var isObject = type !== null && (type === 'object' || type === 'function');
return type + ':' + (isObject ? CID(obj) : obj);
}
};
});
/*can-util@3.7.0#js/cid-set/cid-set*/
define('can-util/js/cid-set/cid-set', function (require, exports, module) {
(function (global) {
'use strict';
var GLOBAL = require('can-util/js/global/global');
var each = require('can-util/js/each/each');
var getCID = require('can-util/js/cid/get-cid');
var CIDSet;
if (GLOBAL().Set) {
CIDSet = GLOBAL().Set;
} else {
var CIDSet = function () {
this.values = {};
};
CIDSet.prototype.add = function (value) {
this.values[getCID(value)] = value;
};
CIDSet.prototype['delete'] = function (key) {
var has = getCID(key) in this.values;
if (has) {
delete this.values[getCID(key)];
}
return has;
};
CIDSet.prototype.forEach = function (cb, thisArg) {
each(this.values, cb, thisArg);
};
CIDSet.prototype.has = function (value) {
return getCID(value) in this.values;
};
CIDSet.prototype.clear = function (key) {
return this.values = {};
};
Object.defineProperty(CIDSet.prototype, 'size', {
get: function () {
var size = 0;
each(this.values, function () {
size++;
});
return size;
}
});
}
module.exports = CIDSet;
}(function () {
return this;
}()));
});
/*can-util@3.7.0#dom/mutation-observer/document/document*/
define('can-util/dom/mutation-observer/document/document', function (require, exports, module) {
(function (global) {
'use strict';
var getDocument = require('can-util/dom/document/document');
var domDataCore = require('can-util/dom/data/core');
var MUTATION_OBSERVER = require('can-util/dom/mutation-observer/mutation-observer');
var each = require('can-util/js/each/each');
var CIDStore = require('can-util/js/cid-set/cid-set');
var makeArray = require('can-util/js/make-array/make-array');
var string = require('can-util/js/string/string');
var dispatchIfListening = function (mutatedNode, nodes, dispatched) {
if (dispatched.has(mutatedNode)) {
return true;
}
dispatched.add(mutatedNode);
if (nodes.name === 'removedNodes') {
var documentElement = getDocument().documentElement;
if (documentElement.contains(mutatedNode)) {
return;
}
}
nodes.handlers.forEach(function (handler) {
handler(mutatedNode);
});
nodes.afterHandlers.forEach(function (handler) {
handler(mutatedNode);
});
};
var mutationObserverDocument = {
add: function (handler) {
var MO = MUTATION_OBSERVER();
if (MO) {
var documentElement = getDocument().documentElement;
var globalObserverData = domDataCore.get.call(documentElement, 'globalObserverData');
if (!globalObserverData) {
var observer = new MO(function (mutations) {
globalObserverData.handlers.forEach(function (handler) {
handler(mutations);
});
});
observer.observe(documentElement, {
childList: true,
subtree: true
});
globalObserverData = {
observer: observer,
handlers: []
};
domDataCore.set.call(documentElement, 'globalObserverData', globalObserverData);
}
globalObserverData.handlers.push(handler);
}
},
remove: function (handler) {
var documentElement = getDocument().documentElement;
var globalObserverData = domDataCore.get.call(documentElement, 'globalObserverData');
if (globalObserverData) {
var index = globalObserverData.handlers.indexOf(handler);
if (index >= 0) {
globalObserverData.handlers.splice(index, 1);
}
if (globalObserverData.handlers.length === 0) {
globalObserverData.observer.disconnect();
domDataCore.clean.call(documentElement, 'globalObserverData');
}
}
}
};
var makeMutationMethods = function (name) {
var mutationName = name.toLowerCase() + 'Nodes';
var getMutationData = function () {
var documentElement = getDocument().documentElement;
var mutationData = domDataCore.get.call(documentElement, mutationName + 'MutationData');
if (!mutationData) {
mutationData = {
name: mutationName,
handlers: [],
afterHandlers: [],
hander: null
};
if (MUTATION_OBSERVER()) {
domDataCore.set.call(documentElement, mutationName + 'MutationData', mutationData);
}
}
return mutationData;
};
var setup = function () {
var mutationData = getMutationData();
if (mutationData.handlers.length === 0 || mutationData.afterHandlers.length === 0) {
mutationData.handler = function (mutations) {
var dispatched = new CIDStore();
mutations.forEach(function (mutation) {
each(mutation[mutationName], function (mutatedNode) {
var children = mutatedNode.getElementsByTagName && makeArray(mutatedNode.getElementsByTagName('*'));
var alreadyChecked = dispatchIfListening(mutatedNode, mutationData, dispatched);
if (children && !alreadyChecked) {
for (var j = 0, child; (child = children[j]) !== undefined; j++) {
dispatchIfListening(child, mutationData, dispatched);
}
}
});
});
};
this.add(mutationData.handler);
}
return mutationData;
};
var teardown = function () {
var documentElement = getDocument().documentElement;
var mutationData = getMutationData();
if (mutationData.handlers.length === 0 && mutationData.afterHandlers.length === 0) {
this.remove(mutationData.handler);
domDataCore.clean.call(documentElement, mutationName + 'MutationData');
}
};
var createOnOffHandlers = function (name, handlerList) {
mutationObserverDocument['on' + name] = function (handler) {
var mutationData = setup.call(this);
mutationData[handlerList].push(handler);
};
mutationObserverDocument['off' + name] = function (handler) {
var mutationData = getMutationData();
var index = mutationData[handlerList].indexOf(handler);
if (index >= 0) {
mutationData[handlerList].splice(index, 1);
}
teardown.call(this);
};
};
var createHandlers = function (name) {
createOnOffHandlers(name, 'handlers');
createOnOffHandlers('After' + name, 'afterHandlers');
};
createHandlers(string.capitalize(mutationName));
};
makeMutationMethods('added');
makeMutationMethods('removed');
module.exports = mutationObserverDocument;
}(function () {
return this;
}()));
});
/*can-util@3.7.0#dom/data/data*/
define('can-util/dom/data/data', function (require, exports, module) {
'use strict';
var domDataCore = require('can-util/dom/data/core');
var mutationDocument = require('can-util/dom/mutation-observer/document/document');
var deleteNode = function () {
return domDataCore.delete.call(this);
};
var elementSetCount = 0;
var cleanupDomData = function (node) {
elementSetCount -= deleteNode.call(node) ? 1 : 0;
if (elementSetCount === 0) {
mutationDocument.offAfterRemovedNodes(cleanupDomData);
}
};
module.exports = {
getCid: domDataCore.getCid,
cid: domDataCore.cid,
expando: domDataCore.expando,
clean: domDataCore.clean,
get: domDataCore.get,
set: function (name, value) {
if (elementSetCount === 0) {
mutationDocument.onAfterRemovedNodes(cleanupDomData);
}
elementSetCount += domDataCore.set.call(this, name, value) ? 1 : 0;
},
delete: deleteNode
};
});
/*can-util@3.7.0#dom/class-name/class-name*/
define('can-util/dom/class-name/class-name', function (require, exports, module) {
'use strict';
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.7.0#js/is-browser-window/is-browser-window*/
define('can-util/js/is-browser-window/is-browser-window', function (require, exports, module) {
(function (global) {
'use strict';
module.exports = function () {
return typeof window !== 'undefined' && typeof document !== 'undefined' && typeof SimpleDOM === 'undefined';
};
}(function () {
return this;
}()));
});
/*can-util@3.7.0#dom/events/events*/
define('can-util/dom/events/events', function (require, exports, module) {
'use strict';
var _document = require('can-util/dom/document/document');
var isBrowserWindow = require('can-util/js/is-browser-window/is-browser-window');
var isPlainObject = require('can-util/js/is-plain-object/is-plain-object');
var fixSyntheticEventsOnDisabled = false;
function isDispatchingOnDisabled(element, ev) {
var isInsertedOrRemoved = isPlainObject(ev) ? ev.type === 'inserted' || ev.type === 'removed' : ev === 'inserted' || ev === 'removed';
var isDisabled = !!element.disabled;
return isInsertedOrRemoved && isDisabled;
}
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 ret;
var dispatchingOnDisabled = fixSyntheticEventsOnDisabled && isDispatchingOnDisabled(this, event);
var ev = doc.createEvent('HTMLEvents');
var isString = typeof event === 'string';
ev.initEvent(isString ? event : event.type, bubbles === undefined ? true : bubbles, false);
if (!isString) {
for (var prop in event) {
if (ev[prop] === undefined) {
ev[prop] = event[prop];
}
}
}
ev.args = args;
if (dispatchingOnDisabled) {
this.disabled = false;
}
ret = this.dispatchEvent(ev);
if (dispatchingOnDisabled) {
this.disabled = true;
}
return ret;
}
};
(function () {
if (!isBrowserWindow()) {
return;
}
var input = document.createElement('input');
input.disabled = true;
var timer = setTimeout(function () {
fixSyntheticEventsOnDisabled = true;
}, 50);
module.exports.addEventListener.call(input, 'foo', function () {
clearTimeout(timer);
});
try {
module.exports.dispatch.call(input, 'foo', [], false);
} catch (e) {
clearTimeout(timer);
fixSyntheticEventsOnDisabled = true;
}
}());
});
/*can-util@3.7.0#dom/dispatch/dispatch*/
define('can-util/dom/dispatch/dispatch', function (require, exports, module) {
'use strict';
var domEvents = require('can-util/dom/events/events');
module.exports = function () {
return domEvents.dispatch.apply(this, arguments);
};
});
/*can-util@3.7.0#dom/matches/matches*/
define('can-util/dom/matches/matches', function (require, exports, module) {
'use strict';
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.7.0#dom/events/delegate/delegate*/
define('can-util/dom/events/delegate/delegate', function (require, exports, module) {
'use strict';
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];