diff --git a/dist/amd/can-component.js b/dist/amd/can-component.js
new file mode 100644
index 0000000..6cf1239
--- /dev/null
+++ b/dist/amd/can-component.js
@@ -0,0 +1,261 @@
+/*can-component@3.3.6#can-component*/
+define([
+ 'require',
+ 'exports',
+ 'module',
+ './control/control',
+ 'can-namespace',
+ 'can-construct',
+ 'can-stache-bindings',
+ 'can-view-scope',
+ 'can-view-callbacks',
+ 'can-view-nodelist',
+ 'can-compute',
+ 'can-util/dom/data',
+ 'can-util/dom/mutate',
+ 'can-util/dom/child-nodes',
+ 'can-util/dom/dispatch',
+ 'can-types',
+ 'can-util/js/string',
+ 'can-reflect',
+ 'can-util/js/each',
+ 'can-util/js/assign',
+ 'can-util/js/is-function',
+ 'can-util/js/log',
+ 'can-util/js/dev',
+ 'can-util/js/make-array',
+ 'can-util/js/is-empty-object',
+ 'can-util/dom/events/inserted',
+ 'can-util/dom/events/removed',
+ 'can-view-model'
+], function (require, exports, module) {
+ var ComponentControl = require('./control/control');
+ var namespace = require('can-namespace');
+ var Construct = require('can-construct');
+ var stacheBindings = require('can-stache-bindings');
+ var Scope = require('can-view-scope');
+ var viewCallbacks = require('can-view-callbacks');
+ var nodeLists = require('can-view-nodelist');
+ var compute = require('can-compute');
+ var domData = require('can-util/dom/data');
+ var domMutate = require('can-util/dom/mutate');
+ var getChildNodes = require('can-util/dom/child-nodes');
+ var domDispatch = require('can-util/dom/dispatch');
+ var types = require('can-types');
+ var string = require('can-util/js/string');
+ var canReflect = require('can-reflect');
+ var canEach = require('can-util/js/each');
+ var assign = require('can-util/js/assign');
+ var isFunction = require('can-util/js/is-function');
+ var canLog = require('can-util/js/log');
+ var canDev = require('can-util/js/dev');
+ var makeArray = require('can-util/js/make-array');
+ var isEmptyObject = require('can-util/js/is-empty-object');
+ require('can-util/dom/events/inserted');
+ require('can-util/dom/events/removed');
+ require('can-view-model');
+ function addContext(el, tagData, insertionElementTagData) {
+ var vm;
+ domData.set.call(el, 'preventDataBindings', true);
+ var teardown = stacheBindings.behaviors.viewModel(el, insertionElementTagData, function (initialData) {
+ return vm = compute(initialData);
+ }, undefined, true);
+ if (!teardown) {
+ return tagData;
+ } else {
+ return assign(assign({}, tagData), {
+ teardown: teardown,
+ scope: tagData.scope.add(vm)
+ });
+ }
+ }
+ function makeInsertionTagCallback(tagName, componentTagData, shadowTagData, leakScope, getPrimaryTemplate) {
+ var options = shadowTagData.options._context;
+ return function hookupFunction(el, insertionElementTagData) {
+ var template = getPrimaryTemplate(el) || insertionElementTagData.subtemplate, renderingLightContent = template !== insertionElementTagData.subtemplate;
+ if (template) {
+ delete options.tags[tagName];
+ var tagData;
+ if (renderingLightContent) {
+ if (leakScope.toLightContent) {
+ tagData = addContext(el, {
+ scope: insertionElementTagData.scope.cloneFromRef(),
+ options: insertionElementTagData.options
+ }, insertionElementTagData);
+ } else {
+ tagData = addContext(el, componentTagData, insertionElementTagData);
+ }
+ } else {
+ tagData = addContext(el, insertionElementTagData, insertionElementTagData);
+ }
+ var nodeList = nodeLists.register([el], function () {
+ if (tagData.teardown) {
+ tagData.teardown();
+ }
+ }, insertionElementTagData.parentNodeList || true, false);
+ nodeList.expression = '';
+ var frag = template(tagData.scope, tagData.options, nodeList);
+ var newNodes = makeArray(getChildNodes(frag));
+ nodeLists.replace(nodeList, frag);
+ nodeLists.update(nodeList, newNodes);
+ options.tags[tagName] = hookupFunction;
+ }
+ };
+ }
+ var Component = Construct.extend({
+ setup: function () {
+ Construct.setup.apply(this, arguments);
+ if (Component) {
+ var self = this;
+ if (!isEmptyObject(this.prototype.events)) {
+ this.Control = ComponentControl.extend(this.prototype.events);
+ }
+ var protoViewModel = this.prototype.viewModel || this.prototype.scope;
+ if (protoViewModel && this.prototype.ViewModel) {
+ throw new Error('Cannot provide both a ViewModel and a viewModel property');
+ }
+ var vmName = string.capitalize(string.camelize(this.prototype.tag)) + 'VM';
+ if (this.prototype.ViewModel) {
+ if (typeof this.prototype.ViewModel === 'function') {
+ this.ViewModel = this.prototype.ViewModel;
+ } else {
+ this.ViewModel = types.DefaultMap.extend(vmName, this.prototype.ViewModel);
+ }
+ } else {
+ if (protoViewModel) {
+ if (typeof protoViewModel === 'function') {
+ if (canReflect.isObservableLike(protoViewModel.prototype) && canReflect.isMapLike(protoViewModel.prototype)) {
+ this.ViewModel = protoViewModel;
+ } else {
+ this.viewModelHandler = protoViewModel;
+ }
+ } else {
+ if (canReflect.isObservableLike(protoViewModel) && canReflect.isMapLike(protoViewModel)) {
+ this.viewModelInstance = protoViewModel;
+ } else {
+ this.ViewModel = types.DefaultMap.extend(vmName, protoViewModel);
+ }
+ }
+ } else {
+ this.ViewModel = types.DefaultMap.extend(vmName, {});
+ }
+ }
+ if (this.prototype.template) {
+ this.renderer = this.prototype.template;
+ }
+ if (this.prototype.view) {
+ this.renderer = this.prototype.view;
+ }
+ viewCallbacks.tag(this.prototype.tag, function (el, options) {
+ new self(el, options);
+ });
+ }
+ }
+ }, {
+ setup: function (el, componentTagData) {
+ var component = this;
+ var teardownFunctions = [];
+ var initialViewModelData = {};
+ var callTeardownFunctions = function () {
+ for (var i = 0, len = teardownFunctions.length; i < len; i++) {
+ teardownFunctions[i]();
+ }
+ };
+ var setupBindings = !domData.get.call(el, 'preventDataBindings');
+ var viewModel, frag;
+ var teardownBindings;
+ if (setupBindings) {
+ var setupFn = componentTagData.setupBindings || function (el, callback, data) {
+ return stacheBindings.behaviors.viewModel(el, componentTagData, callback, data);
+ };
+ teardownBindings = setupFn(el, function (initialViewModelData) {
+ var ViewModel = component.constructor.ViewModel, viewModelHandler = component.constructor.viewModelHandler, viewModelInstance = component.constructor.viewModelInstance;
+ if (viewModelHandler) {
+ var scopeResult = viewModelHandler.call(component, initialViewModelData, componentTagData.scope, el);
+ if (canReflect.isObservableLike(scopeResult) && canReflect.isMapLike(scopeResult)) {
+ viewModelInstance = scopeResult;
+ } else if (canReflect.isObservableLike(scopeResult.prototype) && canReflect.isMapLike(scopeResult.prototype)) {
+ ViewModel = scopeResult;
+ } else {
+ ViewModel = types.DefaultMap.extend(scopeResult);
+ }
+ }
+ if (ViewModel) {
+ viewModelInstance = new component.constructor.ViewModel(initialViewModelData);
+ }
+ viewModel = viewModelInstance;
+ return viewModelInstance;
+ }, initialViewModelData);
+ }
+ this.viewModel = viewModel;
+ domData.set.call(el, 'viewModel', viewModel);
+ domData.set.call(el, 'preventDataBindings', true);
+ var options = {
+ helpers: {},
+ tags: {}
+ };
+ canEach(this.helpers || {}, function (val, prop) {
+ if (isFunction(val)) {
+ options.helpers[prop] = val.bind(viewModel);
+ }
+ });
+ if (this.constructor.Control) {
+ this._control = new this.constructor.Control(el, {
+ scope: this.viewModel,
+ viewModel: this.viewModel,
+ destroy: callTeardownFunctions
+ });
+ }
+ var leakScope = {
+ toLightContent: this.leakScope === true,
+ intoShadowContent: this.leakScope === true
+ };
+ var hasShadowTemplate = !!this.constructor.renderer;
+ var betweenTagsRenderer;
+ var betweenTagsTagData;
+ if (hasShadowTemplate) {
+ var shadowTagData;
+ if (leakScope.intoShadowContent) {
+ shadowTagData = {
+ scope: componentTagData.scope.add(new Scope.Refs()).add(this.viewModel, { viewModel: true }),
+ options: componentTagData.options.add(options)
+ };
+ } else {
+ shadowTagData = {
+ scope: Scope.refsScope().add(this.viewModel, { viewModel: true }),
+ options: new Scope.Options(options)
+ };
+ }
+ options.tags['can-slot'] = makeInsertionTagCallback('can-slot', componentTagData, shadowTagData, leakScope, function (el) {
+ return componentTagData.templates[el.getAttribute('name')];
+ });
+ options.tags.content = makeInsertionTagCallback('content', componentTagData, shadowTagData, leakScope, function () {
+ return componentTagData.subtemplate;
+ });
+ betweenTagsRenderer = this.constructor.renderer;
+ betweenTagsTagData = shadowTagData;
+ } else {
+ var lightTemplateTagData = {
+ scope: componentTagData.scope.add(this.viewModel, { viewModel: true }),
+ options: componentTagData.options.add(options)
+ };
+ betweenTagsTagData = lightTemplateTagData;
+ betweenTagsRenderer = componentTagData.subtemplate || el.ownerDocument.createDocumentFragment.bind(el.ownerDocument);
+ }
+ var nodeList = nodeLists.register([], function () {
+ domDispatch.call(el, 'beforeremove', [], false);
+ if (teardownBindings) {
+ teardownBindings();
+ }
+ }, componentTagData.parentNodeList || true, false);
+ nodeList.expression = '<' + this.tag + '>';
+ teardownFunctions.push(function () {
+ nodeLists.unregister(nodeList);
+ });
+ frag = betweenTagsRenderer(betweenTagsTagData.scope, betweenTagsTagData.options, nodeList);
+ domMutate.appendChild.call(el, frag);
+ nodeLists.update(nodeList, getChildNodes(el));
+ }
+ });
+ module.exports = namespace.Component = Component;
+});
\ No newline at end of file
diff --git a/dist/amd/control/control.js b/dist/amd/control/control.js
new file mode 100644
index 0000000..0daa2d2
--- /dev/null
+++ b/dist/amd/control/control.js
@@ -0,0 +1,68 @@
+/*can-component@3.3.6#control/control*/
+define([
+ 'require',
+ 'exports',
+ 'module',
+ 'can-control',
+ 'can-util/js/each',
+ 'can-util/js/string',
+ 'can-compute',
+ 'can-stache-key'
+], function (require, exports, module) {
+ var Control = require('can-control');
+ var canEach = require('can-util/js/each');
+ var string = require('can-util/js/string');
+ var canCompute = require('can-compute');
+ var observeReader = require('can-stache-key');
+ var paramReplacer = /\{([^\}]+)\}/g;
+ var ComponentControl = Control.extend({
+ _lookup: function (options) {
+ return [
+ options.scope,
+ options,
+ window
+ ];
+ },
+ _removeDelegateFromKey: function (key) {
+ return key.replace(/^(scope|^viewModel)\./, '');
+ },
+ _isDelegate: function (options, key) {
+ return key === 'scope' || key === 'viewModel';
+ },
+ _getDelegate: function (options, key) {
+ return options[key];
+ },
+ _action: function (methodName, options, controlInstance) {
+ var hasObjectLookup;
+ paramReplacer.lastIndex = 0;
+ hasObjectLookup = paramReplacer.test(methodName);
+ if (!controlInstance && hasObjectLookup) {
+ return;
+ } else {
+ return Control._action.apply(this, arguments);
+ }
+ }
+ }, {
+ setup: function (el, options) {
+ this.scope = options.scope;
+ this.viewModel = options.viewModel;
+ return Control.prototype.setup.call(this, el, options);
+ },
+ off: function () {
+ if (this._bindings) {
+ canEach(this._bindings.readyComputes || {}, function (value) {
+ value.compute.unbind('change', value.handler);
+ });
+ }
+ Control.prototype.off.apply(this, arguments);
+ this._bindings.readyComputes = {};
+ },
+ destroy: function () {
+ Control.prototype.destroy.apply(this, arguments);
+ if (typeof this.options.destroy === 'function') {
+ this.options.destroy.apply(this, arguments);
+ }
+ }
+ });
+ module.exports = ComponentControl;
+});
\ No newline at end of file
diff --git a/dist/global/can-component.js b/dist/global/can-component.js
new file mode 100644
index 0000000..abcc1a0
--- /dev/null
+++ b/dist/global/can-component.js
@@ -0,0 +1,11869 @@
+/*[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 hasCjsDependencies = function(deps) {
+ return (
+ deps[0] === "require" && deps[1] === "exports" && deps[2] === "module"
+ );
+ };
+
+ 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 (hasCjsDependencies(deps) || (!deps.length && callback.length)) {
+ module = { exports: {} };
+ args[0] = function(name) {
+ return exports[name] ? get(exports[name]) : modules[name];
+ };
+ args[1] = module.exports;
+ args[2] = module;
+ } else if (!args[0] && deps[0] === "exports") {
+ // Babel uses the exports and module object.
+ 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);
+ }
+ };
+ });
+})(
+ { "can-namespace": "can" },
+ typeof self == "object" && self.Object == Object ? self : window,
+ function(__$source__, __$global__) {
+ // jshint ignore:line
+ eval("(function() { " + __$source__ + " \n }).call(__$global__);");
+ }
+);
+
+/*can-assign@1.1.1#can-assign*/
+define('can-assign', function (require, exports, module) {
+ module.exports = function (d, s) {
+ for (var prop in s) {
+ d[prop] = s[prop];
+ }
+ return d;
+ };
+});
+/*can-util@3.10.18#js/assign/assign*/
+define('can-util/js/assign/assign', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-assign'
+], function (require, exports, module) {
+ 'use strict';
+ module.exports = require('can-assign');
+});
+/*can-util@3.10.18#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.10.18#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) || obj.constructor && obj.constructor.shortName) {
+ 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.10.18#js/deep-assign/deep-assign*/
+define('can-util/js/deep-assign/deep-assign', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/is-function/is-function',
+ 'can-util/js/is-plain-object/is-plain-object'
+], function (require, exports, module) {
+ 'use strict';
+ 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 = Array.isArray(copy)))) {
+ if (copyIsArray) {
+ copyIsArray = false;
+ clone = src && Array.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-log@0.1.2#can-log*/
+define('can-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-log@0.1.2#dev/dev*/
+define('can-log/dev/dev', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-log'
+], function (require, exports, module) {
+ 'use strict';
+ var canLog = require('can-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 () {
+ },
+ log: function () {
+ },
+ error: function () {
+ },
+ _logger: canLog._logger
+ };
+});
+/*can-util@3.10.18#js/dev/dev*/
+define('can-util/js/dev/dev', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-log/dev/dev'
+], function (require, exports, module) {
+ 'use strict';
+ module.exports = require('can-log/dev/dev');
+});
+/*can-util@3.10.18#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-namespace@1.0.0#can-namespace*/
+define('can-namespace', function (require, exports, module) {
+ module.exports = {};
+});
+/*can-symbol@1.4.2#can-symbol*/
+define('can-symbol', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ var namespace = require('can-namespace');
+ var CanSymbol;
+ if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {
+ CanSymbol = Symbol;
+ } else {
+ var symbolNum = 0;
+ CanSymbol = function CanSymbolPolyfill(description) {
+ var symbolValue = '@@symbol' + symbolNum++ + description;
+ var symbol = {};
+ Object.defineProperties(symbol, {
+ toString: {
+ value: function () {
+ return symbolValue;
+ }
+ }
+ });
+ return symbol;
+ };
+ var descriptionToSymbol = {};
+ var symbolToDescription = {};
+ CanSymbol.for = function (description) {
+ var symbol = descriptionToSymbol[description];
+ if (!symbol) {
+ symbol = descriptionToSymbol[description] = CanSymbol(description);
+ symbolToDescription[symbol] = description;
+ }
+ return symbol;
+ };
+ CanSymbol.keyFor = function (symbol) {
+ return symbolToDescription[symbol];
+ };
+ [
+ 'hasInstance',
+ 'isConcatSpreadable',
+ 'iterator',
+ 'match',
+ 'prototype',
+ 'replace',
+ 'search',
+ 'species',
+ 'split',
+ 'toPrimitive',
+ 'toStringTag',
+ 'unscopables'
+ ].forEach(function (name) {
+ CanSymbol[name] = CanSymbol.for(name);
+ });
+ }
+ [
+ 'isMapLike',
+ 'isListLike',
+ 'isValueLike',
+ 'isFunctionLike',
+ 'getOwnKeys',
+ 'getOwnKeyDescriptor',
+ 'proto',
+ 'getOwnEnumerableKeys',
+ 'hasOwnKey',
+ 'size',
+ 'getName',
+ 'getIdentity',
+ 'assignDeep',
+ 'updateDeep',
+ 'getValue',
+ 'setValue',
+ 'getKeyValue',
+ 'setKeyValue',
+ 'updateValues',
+ 'addValue',
+ 'removeValues',
+ 'apply',
+ 'new',
+ 'onValue',
+ 'offValue',
+ 'onKeyValue',
+ 'offKeyValue',
+ 'getKeyDependencies',
+ 'getValueDependencies',
+ 'keyHasDependencies',
+ 'valueHasDependencies',
+ 'onKeys',
+ 'onKeysAdded',
+ 'onKeysRemoved'
+ ].forEach(function (name) {
+ CanSymbol.for('can.' + name);
+ });
+ module.exports = namespace.Symbol = CanSymbol;
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#js/is-iterable/is-iterable*/
+define('can-util/js/is-iterable/is-iterable', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol'
+], function (require, exports, module) {
+ 'use strict';
+ var canSymbol = require('can-symbol');
+ module.exports = function (obj) {
+ return obj && !!obj[canSymbol.iterator || canSymbol.for('iterator')];
+ };
+});
+/*can-util@3.10.18#js/each/each*/
+define('can-util/js/each/each', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/is-array-like/is-array-like',
+ 'can-util/js/is-iterable/is-iterable',
+ 'can-symbol'
+], 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 canSymbol = require('can-symbol');
+ 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[canSymbol.iterator || canSymbol.for('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.10.18#js/make-array/make-array*/
+define('can-util/js/make-array/make-array', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/each/each',
+ 'can-util/js/is-array-like/is-array-like'
+], 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.10.18#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.10.18#js/get/get*/
+define('can-util/js/get/get', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/is-container/is-container'
+], 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.10.18#js/is-array/is-array*/
+define('can-util/js/is-array/is-array', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-log/dev/dev'
+], function (require, exports, module) {
+ 'use strict';
+ var dev = require('can-log/dev/dev');
+ var hasWarned = false;
+ module.exports = function (arr) {
+ return Array.isArray(arr);
+ };
+});
+/*can-util@3.10.18#js/string/string*/
+define('can-util/js/string/string', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/get/get',
+ 'can-util/js/is-container/is-container',
+ 'can-log/dev/dev',
+ 'can-util/js/is-array/is-array'
+], 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-log/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(strQuote, '"').replace(strSingleQuote, ''');
+ },
+ getObject: function (name, roots) {
+ 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.2.3#can-construct*/
+define('can-construct', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/assign/assign',
+ 'can-util/js/deep-assign/deep-assign',
+ 'can-util/js/dev/dev',
+ 'can-util/js/make-array/make-array',
+ 'can-namespace'
+], 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 namespace = require('can-namespace');
+ var initializing = 0;
+ 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;
+ }
+ function init() {
+ if (!initializing) {
+ 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 () {
+ };
+ module.exports = namespace.Construct = Construct;
+});
+/*can-reflect@1.10.2#reflections/helpers*/
+define('can-reflect/reflections/helpers', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol'
+], function (require, exports, module) {
+ var canSymbol = require('can-symbol');
+ module.exports = {
+ makeGetFirstSymbolValue: function (symbolNames) {
+ var symbols = symbolNames.map(function (name) {
+ return canSymbol.for(name);
+ });
+ var length = symbols.length;
+ return function getFirstSymbol(obj) {
+ var index = -1;
+ while (++index < length) {
+ if (obj[symbols[index]] !== undefined) {
+ return obj[symbols[index]];
+ }
+ }
+ };
+ },
+ hasLength: function (list) {
+ var type = typeof list;
+ var length = list && type !== 'boolean' && typeof list !== 'number' && 'length' in list && list.length;
+ return typeof list !== 'function' && (length === 0 || typeof length === 'number' && length > 0 && length - 1 in list);
+ }
+ };
+});
+/*can-reflect@1.10.2#reflections/type/type*/
+define('can-reflect/reflections/type/type', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol',
+ 'can-reflect/reflections/helpers'
+], function (require, exports, module) {
+ var canSymbol = require('can-symbol');
+ var helpers = require('can-reflect/reflections/helpers');
+ var plainFunctionPrototypePropertyNames = Object.getOwnPropertyNames(function () {
+ }.prototype);
+ var plainFunctionPrototypeProto = Object.getPrototypeOf(function () {
+ }.prototype);
+ function isConstructorLike(func) {
+ var value = func[canSymbol.for('can.new')];
+ if (value !== undefined) {
+ return value;
+ }
+ if (typeof func !== 'function') {
+ return false;
+ }
+ var prototype = func.prototype;
+ if (!prototype) {
+ return false;
+ }
+ if (plainFunctionPrototypeProto !== Object.getPrototypeOf(prototype)) {
+ return true;
+ }
+ var propertyNames = Object.getOwnPropertyNames(prototype);
+ if (propertyNames.length === plainFunctionPrototypePropertyNames.length) {
+ for (var i = 0, len = propertyNames.length; i < len; i++) {
+ if (propertyNames[i] !== plainFunctionPrototypePropertyNames[i]) {
+ return true;
+ }
+ }
+ return false;
+ } else {
+ return true;
+ }
+ }
+ var getNewOrApply = helpers.makeGetFirstSymbolValue([
+ 'can.new',
+ 'can.apply'
+ ]);
+ function isFunctionLike(obj) {
+ var result, symbolValue = obj[canSymbol.for('can.isFunctionLike')];
+ if (symbolValue !== undefined) {
+ return symbolValue;
+ }
+ result = getNewOrApply(obj);
+ if (result !== undefined) {
+ return !!result;
+ }
+ return typeof obj === 'function';
+ }
+ function isPrimitive(obj) {
+ var type = typeof obj;
+ if (obj == null || type !== 'function' && type !== 'object') {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ function isBuiltIn(obj) {
+ if (isPrimitive(obj) || Array.isArray(obj) || isPlainObject(obj) || Object.prototype.toString.call(obj) !== '[object Object]' && Object.prototype.toString.call(obj).indexOf('[object ') !== -1) {
+ return true;
+ } else {
+ return false;
+ }
+ }
+ function isValueLike(obj) {
+ var symbolValue;
+ if (isPrimitive(obj)) {
+ return true;
+ }
+ symbolValue = obj[canSymbol.for('can.isValueLike')];
+ if (typeof symbolValue !== 'undefined') {
+ return symbolValue;
+ }
+ var value = obj[canSymbol.for('can.getValue')];
+ if (value !== undefined) {
+ return !!value;
+ }
+ }
+ function isMapLike(obj) {
+ if (isPrimitive(obj)) {
+ return false;
+ }
+ var isMapLike = obj[canSymbol.for('can.isMapLike')];
+ if (typeof isMapLike !== 'undefined') {
+ return !!isMapLike;
+ }
+ var value = obj[canSymbol.for('can.getKeyValue')];
+ if (value !== undefined) {
+ return !!value;
+ }
+ return true;
+ }
+ var onValueSymbol = canSymbol.for('can.onValue'), onKeyValueSymbol = canSymbol.for('can.onKeyValue'), onPatchesSymbol = canSymbol.for('can.onPatches');
+ function isObservableLike(obj) {
+ if (isPrimitive(obj)) {
+ return false;
+ }
+ return Boolean(obj[onValueSymbol] || obj[onKeyValueSymbol] || obj[onPatchesSymbol]);
+ }
+ function isListLike(list) {
+ var symbolValue, type = typeof list;
+ if (type === 'string') {
+ return true;
+ }
+ if (isPrimitive(list)) {
+ return false;
+ }
+ symbolValue = list[canSymbol.for('can.isListLike')];
+ if (typeof symbolValue !== 'undefined') {
+ return symbolValue;
+ }
+ var value = list[canSymbol.iterator];
+ if (value !== undefined) {
+ return !!value;
+ }
+ if (Array.isArray(list)) {
+ return true;
+ }
+ return helpers.hasLength(list);
+ }
+ var supportsSymbols = typeof Symbol !== 'undefined' && typeof Symbol.for === 'function';
+ var isSymbolLike;
+ if (supportsSymbols) {
+ isSymbolLike = function (symbol) {
+ return typeof symbol === 'symbol';
+ };
+ } else {
+ var symbolStart = '@@symbol';
+ isSymbolLike = function (symbol) {
+ if (typeof symbol === 'object' && !Array.isArray(symbol)) {
+ return symbol.toString().substr(0, symbolStart.length) === symbolStart;
+ } else {
+ return false;
+ }
+ };
+ }
+ var coreHasOwn = Object.prototype.hasOwnProperty;
+ var funcToString = Function.prototype.toString;
+ var objectCtorString = funcToString.call(Object);
+ function isPlainObject(obj) {
+ if (!obj || typeof obj !== 'object') {
+ return false;
+ }
+ var proto = Object.getPrototypeOf(obj);
+ if (proto === Object.prototype || proto === null) {
+ return true;
+ }
+ var Constructor = coreHasOwn.call(proto, 'constructor') && proto.constructor;
+ return typeof Constructor === 'function' && Constructor instanceof Constructor && funcToString.call(Constructor) === objectCtorString;
+ }
+ module.exports = {
+ isConstructorLike: isConstructorLike,
+ isFunctionLike: isFunctionLike,
+ isListLike: isListLike,
+ isMapLike: isMapLike,
+ isObservableLike: isObservableLike,
+ isPrimitive: isPrimitive,
+ isBuiltIn: isBuiltIn,
+ isValueLike: isValueLike,
+ isSymbolLike: isSymbolLike,
+ isMoreListLikeThanMapLike: function (obj) {
+ if (Array.isArray(obj)) {
+ return true;
+ }
+ if (obj instanceof Array) {
+ return true;
+ }
+ var value = obj[canSymbol.for('can.isMoreListLikeThanMapLike')];
+ if (value !== undefined) {
+ return value;
+ }
+ var isListLike = this.isListLike(obj), isMapLike = this.isMapLike(obj);
+ if (isListLike && !isMapLike) {
+ return true;
+ } else if (!isListLike && isMapLike) {
+ return false;
+ }
+ },
+ isIteratorLike: function (obj) {
+ return obj && typeof obj === 'object' && typeof obj.next === 'function' && obj.next.length === 0;
+ },
+ isPromise: function (obj) {
+ return obj instanceof Promise || Object.prototype.toString.call(obj) === '[object Promise]';
+ },
+ isPlainObject: isPlainObject
+ };
+});
+/*can-reflect@1.10.2#reflections/call/call*/
+define('can-reflect/reflections/call/call', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol',
+ 'can-reflect/reflections/type/type'
+], function (require, exports, module) {
+ var canSymbol = require('can-symbol');
+ var typeReflections = require('can-reflect/reflections/type/type');
+ module.exports = {
+ call: function (func, context) {
+ var args = [].slice.call(arguments, 2);
+ var apply = func[canSymbol.for('can.apply')];
+ if (apply) {
+ return apply.call(func, context, args);
+ } else {
+ return func.apply(context, args);
+ }
+ },
+ apply: function (func, context, args) {
+ var apply = func[canSymbol.for('can.apply')];
+ if (apply) {
+ return apply.call(func, context, args);
+ } else {
+ return func.apply(context, args);
+ }
+ },
+ 'new': function (func) {
+ var args = [].slice.call(arguments, 1);
+ var makeNew = func[canSymbol.for('can.new')];
+ if (makeNew) {
+ return makeNew.apply(func, args);
+ } else {
+ var context = Object.create(func.prototype);
+ var ret = func.apply(context, args);
+ if (typeReflections.isPrimitive(ret)) {
+ return context;
+ } else {
+ return ret;
+ }
+ }
+ }
+ };
+});
+/*can-reflect@1.10.2#reflections/get-set/get-set*/
+define('can-reflect/reflections/get-set/get-set', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol',
+ 'can-reflect/reflections/type/type'
+], function (require, exports, module) {
+ var canSymbol = require('can-symbol');
+ var typeReflections = require('can-reflect/reflections/type/type');
+ var setKeyValueSymbol = canSymbol.for('can.setKeyValue'), getKeyValueSymbol = canSymbol.for('can.getKeyValue'), getValueSymbol = canSymbol.for('can.getValue'), setValueSymbol = canSymbol.for('can.setValue');
+ var reflections = {
+ setKeyValue: function (obj, key, value) {
+ if (typeReflections.isSymbolLike(key)) {
+ if (typeof key === 'symbol') {
+ obj[key] = value;
+ } else {
+ Object.defineProperty(obj, key, {
+ enumerable: false,
+ configurable: true,
+ value: value,
+ writable: true
+ });
+ }
+ return;
+ }
+ var setKeyValue = obj[setKeyValueSymbol];
+ if (setKeyValue !== undefined) {
+ return setKeyValue.call(obj, key, value);
+ } else {
+ obj[key] = value;
+ }
+ },
+ getKeyValue: function (obj, key) {
+ var getKeyValue = obj[getKeyValueSymbol];
+ if (getKeyValue) {
+ return getKeyValue.call(obj, key);
+ }
+ return obj[key];
+ },
+ deleteKeyValue: function (obj, key) {
+ var deleteKeyValue = obj[canSymbol.for('can.deleteKeyValue')];
+ if (deleteKeyValue) {
+ return deleteKeyValue.call(obj, key);
+ }
+ delete obj[key];
+ },
+ getValue: function (value) {
+ if (typeReflections.isPrimitive(value)) {
+ return value;
+ }
+ var getValue = value[getValueSymbol];
+ if (getValue) {
+ return getValue.call(value);
+ }
+ return value;
+ },
+ setValue: function (item, value) {
+ var setValue = item && item[setValueSymbol];
+ if (setValue) {
+ return setValue.call(item, value);
+ } else {
+ throw new Error('can-reflect.setValue - Can not set value.');
+ }
+ },
+ splice: function (obj, index, removing, adding) {
+ var howMany;
+ if (typeof removing !== 'number') {
+ var updateValues = obj[canSymbol.for('can.updateValues')];
+ if (updateValues) {
+ return updateValues.call(obj, index, removing, adding);
+ }
+ howMany = removing.length;
+ } else {
+ howMany = removing;
+ }
+ var splice = obj[canSymbol.for('can.splice')];
+ if (splice) {
+ return splice.call(obj, index, howMany, adding);
+ }
+ return [].splice.apply(obj, [
+ index,
+ howMany
+ ].concat(adding));
+ },
+ addValues: function (obj, adding, index) {
+ var add = obj[canSymbol.for('can.addValues')];
+ if (add) {
+ return add.call(obj, adding, index);
+ }
+ if (Array.isArray(obj) && index === undefined) {
+ return obj.push.apply(obj, adding);
+ }
+ return reflections.splice(obj, index, [], adding);
+ },
+ removeValues: function (obj, removing, index) {
+ var removeValues = obj[canSymbol.for('can.removeValues')];
+ if (removeValues) {
+ return removeValues.call(obj, removing, index);
+ }
+ if (Array.isArray(obj) && index === undefined) {
+ removing.forEach(function (item) {
+ var index = obj.indexOf(item);
+ if (index >= 0) {
+ obj.splice(index, 1);
+ }
+ });
+ return;
+ }
+ return reflections.splice(obj, index, removing, []);
+ }
+ };
+ reflections.get = reflections.getKeyValue;
+ reflections.set = reflections.setKeyValue;
+ reflections['delete'] = reflections.deleteKeyValue;
+ module.exports = reflections;
+});
+/*can-reflect@1.10.2#reflections/observe/observe*/
+define('can-reflect/reflections/observe/observe', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol'
+], function (require, exports, module) {
+ var canSymbol = require('can-symbol');
+ var slice = [].slice;
+ function makeFallback(symbolName, fallbackName) {
+ return function (obj, event, handler, queueName) {
+ var method = obj[canSymbol.for(symbolName)];
+ if (method !== undefined) {
+ return method.call(obj, event, handler, queueName);
+ }
+ return this[fallbackName].apply(this, arguments);
+ };
+ }
+ function makeErrorIfMissing(symbolName, errorMessage) {
+ return function (obj) {
+ var method = obj[canSymbol.for(symbolName)];
+ if (method !== undefined) {
+ var args = slice.call(arguments, 1);
+ return method.apply(obj, args);
+ }
+ throw new Error(errorMessage);
+ };
+ }
+ module.exports = {
+ onKeyValue: makeFallback('can.onKeyValue', 'onEvent'),
+ offKeyValue: makeFallback('can.offKeyValue', 'offEvent'),
+ onKeys: makeErrorIfMissing('can.onKeys', 'can-reflect: can not observe an onKeys event'),
+ onKeysAdded: makeErrorIfMissing('can.onKeysAdded', 'can-reflect: can not observe an onKeysAdded event'),
+ onKeysRemoved: makeErrorIfMissing('can.onKeysRemoved', 'can-reflect: can not unobserve an onKeysRemoved event'),
+ getKeyDependencies: makeErrorIfMissing('can.getKeyDependencies', 'can-reflect: can not determine dependencies'),
+ getWhatIChange: makeErrorIfMissing('can.getWhatIChange', 'can-reflect: can not determine dependencies'),
+ getChangesDependencyRecord: function getChangesDependencyRecord(handler) {
+ var fn = handler[canSymbol.for('can.getChangesDependencyRecord')];
+ if (typeof fn === 'function') {
+ return fn();
+ }
+ },
+ keyHasDependencies: makeErrorIfMissing('can.keyHasDependencies', 'can-reflect: can not determine if this has key dependencies'),
+ onValue: makeErrorIfMissing('can.onValue', 'can-reflect: can not observe value change'),
+ offValue: makeErrorIfMissing('can.offValue', 'can-reflect: can not unobserve value change'),
+ getValueDependencies: makeErrorIfMissing('can.getValueDependencies', 'can-reflect: can not determine dependencies'),
+ valueHasDependencies: makeErrorIfMissing('can.valueHasDependencies', 'can-reflect: can not determine if value has dependencies'),
+ onPatches: makeErrorIfMissing('can.onPatches', 'can-reflect: can not observe patches on object'),
+ offPatches: makeErrorIfMissing('can.offPatches', 'can-reflect: can not unobserve patches on object'),
+ onInstanceBoundChange: makeErrorIfMissing('can.onInstanceBoundChange', 'can-reflect: can not observe bound state change in instances.'),
+ offInstanceBoundChange: makeErrorIfMissing('can.offInstanceBoundChange', 'can-reflect: can not unobserve bound state change'),
+ isBound: makeErrorIfMissing('can.isBound', 'can-reflect: cannot determine if object is bound'),
+ onEvent: function (obj, eventName, callback, queue) {
+ if (obj) {
+ var onEvent = obj[canSymbol.for('can.onEvent')];
+ if (onEvent !== undefined) {
+ return onEvent.call(obj, eventName, callback, queue);
+ } else if (obj.addEventListener) {
+ obj.addEventListener(eventName, callback, queue);
+ }
+ }
+ },
+ offEvent: function (obj, eventName, callback, queue) {
+ if (obj) {
+ var offEvent = obj[canSymbol.for('can.offEvent')];
+ if (offEvent !== undefined) {
+ return offEvent.call(obj, eventName, callback, queue);
+ } else if (obj.removeEventListener) {
+ obj.removeEventListener(eventName, callback, queue);
+ }
+ }
+ },
+ setPriority: function (obj, priority) {
+ if (obj) {
+ var setPriority = obj[canSymbol.for('can.setPriority')];
+ if (setPriority !== undefined) {
+ setPriority.call(obj, priority);
+ return true;
+ }
+ }
+ return false;
+ },
+ getPriority: function (obj) {
+ if (obj) {
+ var getPriority = obj[canSymbol.for('can.getPriority')];
+ if (getPriority !== undefined) {
+ return getPriority.call(obj);
+ }
+ }
+ return undefined;
+ }
+ };
+});
+/*can-reflect@1.10.2#reflections/shape/shape*/
+define('can-reflect/reflections/shape/shape', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol',
+ 'can-reflect/reflections/get-set/get-set',
+ 'can-reflect/reflections/type/type',
+ 'can-reflect/reflections/helpers'
+], function (require, exports, module) {
+ var canSymbol = require('can-symbol');
+ var getSetReflections = require('can-reflect/reflections/get-set/get-set');
+ var typeReflections = require('can-reflect/reflections/type/type');
+ var helpers = require('can-reflect/reflections/helpers');
+ var shapeReflections;
+ var shiftFirstArgumentToThis = function (func) {
+ return function () {
+ var args = [this];
+ args.push.apply(args, arguments);
+ return func.apply(null, args);
+ };
+ };
+ var getKeyValueSymbol = canSymbol.for('can.getKeyValue');
+ var shiftedGetKeyValue = shiftFirstArgumentToThis(getSetReflections.getKeyValue);
+ var setKeyValueSymbol = canSymbol.for('can.setKeyValue');
+ var shiftedSetKeyValue = shiftFirstArgumentToThis(getSetReflections.setKeyValue);
+ var sizeSymbol = canSymbol.for('can.size');
+ var serializeMap = null;
+ var hasUpdateSymbol = helpers.makeGetFirstSymbolValue([
+ 'can.updateDeep',
+ 'can.assignDeep',
+ 'can.setKeyValue'
+ ]);
+ var shouldUpdateOrAssign = function (obj) {
+ return typeReflections.isPlainObject(obj) || Array.isArray(obj) || !!hasUpdateSymbol(obj);
+ };
+ function isSerializable(obj) {
+ if (typeReflections.isPrimitive(obj)) {
+ return true;
+ }
+ if (hasUpdateSymbol(obj)) {
+ return false;
+ }
+ return typeReflections.isBuiltIn(obj) && !typeReflections.isPlainObject(obj);
+ }
+ var Object_Keys;
+ try {
+ Object.keys(1);
+ Object_Keys = Object.keys;
+ } catch (e) {
+ Object_Keys = function (obj) {
+ if (typeReflections.isPrimitive(obj)) {
+ return [];
+ } else {
+ return Object.keys(obj);
+ }
+ };
+ }
+ function makeSerializer(methodName, symbolsToCheck) {
+ return function serializer(value, MapType) {
+ if (isSerializable(value)) {
+ return value;
+ }
+ var firstSerialize;
+ if (MapType && !serializeMap) {
+ serializeMap = {
+ unwrap: new MapType(),
+ serialize: new MapType()
+ };
+ firstSerialize = true;
+ }
+ var serialized;
+ if (typeReflections.isValueLike(value)) {
+ serialized = this[methodName](getSetReflections.getValue(value));
+ } else {
+ var isListLike = typeReflections.isIteratorLike(value) || typeReflections.isMoreListLikeThanMapLike(value);
+ serialized = isListLike ? [] : {};
+ if (serializeMap) {
+ if (serializeMap[methodName].has(value)) {
+ return serializeMap[methodName].get(value);
+ } else {
+ serializeMap[methodName].set(value, serialized);
+ }
+ }
+ for (var i = 0, len = symbolsToCheck.length; i < len; i++) {
+ var serializer = value[symbolsToCheck[i]];
+ if (serializer) {
+ var result = serializer.call(value, serialized);
+ if (firstSerialize) {
+ serializeMap = null;
+ }
+ return result;
+ }
+ }
+ if (typeof obj === 'function') {
+ if (serializeMap) {
+ serializeMap[methodName].set(value, value);
+ }
+ serialized = value;
+ } else if (isListLike) {
+ this.eachIndex(value, function (childValue, index) {
+ serialized[index] = this[methodName](childValue);
+ }, this);
+ } else {
+ this.eachKey(value, function (childValue, prop) {
+ serialized[prop] = this[methodName](childValue);
+ }, this);
+ }
+ }
+ if (firstSerialize) {
+ serializeMap = null;
+ }
+ return serialized;
+ };
+ }
+ var makeMap;
+ if (typeof Map !== 'undefined') {
+ makeMap = function (keys) {
+ var map = new Map();
+ shapeReflections.eachIndex(keys, function (key) {
+ map.set(key, true);
+ });
+ return map;
+ };
+ } else {
+ makeMap = function (keys) {
+ var map = {};
+ keys.forEach(function (key) {
+ map[key] = true;
+ });
+ return {
+ get: function (key) {
+ return map[key];
+ },
+ set: function (key, value) {
+ map[key] = value;
+ },
+ keys: function () {
+ return keys;
+ }
+ };
+ };
+ }
+ var fastHasOwnKey = function (obj) {
+ var hasOwnKey = obj[canSymbol.for('can.hasOwnKey')];
+ if (hasOwnKey) {
+ return hasOwnKey.bind(obj);
+ } else {
+ var map = makeMap(shapeReflections.getOwnEnumerableKeys(obj));
+ return function (key) {
+ return map.get(key);
+ };
+ }
+ };
+ function addPatch(patches, patch) {
+ var lastPatch = patches[patches.length - 1];
+ if (lastPatch) {
+ if (lastPatch.deleteCount === lastPatch.insert.length && patch.index - lastPatch.index === lastPatch.deleteCount) {
+ lastPatch.insert.push.apply(lastPatch.insert, patch.insert);
+ lastPatch.deleteCount += patch.deleteCount;
+ return;
+ }
+ }
+ patches.push(patch);
+ }
+ function updateDeepList(target, source, isAssign) {
+ var sourceArray = this.toArray(source);
+ var patches = [], lastIndex = -1;
+ this.eachIndex(target, function (curVal, index) {
+ lastIndex = index;
+ if (index >= sourceArray.length) {
+ if (!isAssign) {
+ addPatch(patches, {
+ index: index,
+ deleteCount: sourceArray.length - index + 1,
+ insert: []
+ });
+ }
+ return false;
+ }
+ var newVal = sourceArray[index];
+ if (typeReflections.isPrimitive(curVal) || typeReflections.isPrimitive(newVal) || shouldUpdateOrAssign(curVal) === false) {
+ addPatch(patches, {
+ index: index,
+ deleteCount: 1,
+ insert: [newVal]
+ });
+ } else {
+ this.updateDeep(curVal, newVal);
+ }
+ }, this);
+ if (sourceArray.length > lastIndex) {
+ addPatch(patches, {
+ index: lastIndex + 1,
+ deleteCount: 0,
+ insert: sourceArray.slice(lastIndex + 1)
+ });
+ }
+ for (var i = 0, patchLen = patches.length; i < patchLen; i++) {
+ var patch = patches[i];
+ getSetReflections.splice(target, patch.index, patch.deleteCount, patch.insert);
+ }
+ return target;
+ }
+ shapeReflections = {
+ each: function (obj, callback, context) {
+ if (typeReflections.isIteratorLike(obj) || typeReflections.isMoreListLikeThanMapLike(obj)) {
+ return this.eachIndex(obj, callback, context);
+ } else {
+ return this.eachKey(obj, callback, context);
+ }
+ },
+ eachIndex: function (list, callback, context) {
+ if (Array.isArray(list)) {
+ return this.eachListLike(list, callback, context);
+ } else {
+ var iter, iterator = list[canSymbol.iterator];
+ if (typeReflections.isIteratorLike(list)) {
+ iter = list;
+ } else if (iterator) {
+ iter = iterator.call(list);
+ }
+ if (iter) {
+ var res, index = 0;
+ while (!(res = iter.next()).done) {
+ if (callback.call(context || list, res.value, index++, list) === false) {
+ break;
+ }
+ }
+ } else {
+ this.eachListLike(list, callback, context);
+ }
+ }
+ return list;
+ },
+ eachListLike: function (list, callback, context) {
+ var index = -1;
+ var length = list.length;
+ if (length === undefined) {
+ var size = list[sizeSymbol];
+ if (size) {
+ length = size.call(list);
+ } else {
+ throw new Error('can-reflect: unable to iterate.');
+ }
+ }
+ while (++index < length) {
+ var item = list[index];
+ if (callback.call(context || item, item, index, list) === false) {
+ break;
+ }
+ }
+ return list;
+ },
+ toArray: function (obj) {
+ var arr = [];
+ this.each(obj, function (value) {
+ arr.push(value);
+ });
+ return arr;
+ },
+ eachKey: function (obj, callback, context) {
+ if (obj) {
+ var enumerableKeys = this.getOwnEnumerableKeys(obj);
+ var getKeyValue = obj[getKeyValueSymbol] || shiftedGetKeyValue;
+ return this.eachIndex(enumerableKeys, function (key) {
+ var value = getKeyValue.call(obj, key);
+ return callback.call(context || obj, value, key, obj);
+ });
+ }
+ return obj;
+ },
+ 'hasOwnKey': function (obj, key) {
+ var hasOwnKey = obj[canSymbol.for('can.hasOwnKey')];
+ if (hasOwnKey) {
+ return hasOwnKey.call(obj, key);
+ }
+ var getOwnKeys = obj[canSymbol.for('can.getOwnKeys')];
+ if (getOwnKeys) {
+ var found = false;
+ this.eachIndex(getOwnKeys.call(obj), function (objKey) {
+ if (objKey === key) {
+ found = true;
+ return false;
+ }
+ });
+ return found;
+ }
+ return obj.hasOwnProperty(key);
+ },
+ getOwnEnumerableKeys: function (obj) {
+ var getOwnEnumerableKeys = obj[canSymbol.for('can.getOwnEnumerableKeys')];
+ if (getOwnEnumerableKeys) {
+ return getOwnEnumerableKeys.call(obj);
+ }
+ if (obj[canSymbol.for('can.getOwnKeys')] && obj[canSymbol.for('can.getOwnKeyDescriptor')]) {
+ var keys = [];
+ this.eachIndex(this.getOwnKeys(obj), function (key) {
+ var descriptor = this.getOwnKeyDescriptor(obj, key);
+ if (descriptor.enumerable) {
+ keys.push(key);
+ }
+ }, this);
+ return keys;
+ } else {
+ return Object_Keys(obj);
+ }
+ },
+ getOwnKeys: function (obj) {
+ var getOwnKeys = obj[canSymbol.for('can.getOwnKeys')];
+ if (getOwnKeys) {
+ return getOwnKeys.call(obj);
+ } else {
+ return Object.getOwnPropertyNames(obj);
+ }
+ },
+ getOwnKeyDescriptor: function (obj, key) {
+ var getOwnKeyDescriptor = obj[canSymbol.for('can.getOwnKeyDescriptor')];
+ if (getOwnKeyDescriptor) {
+ return getOwnKeyDescriptor.call(obj, key);
+ } else {
+ return Object.getOwnPropertyDescriptor(obj, key);
+ }
+ },
+ unwrap: makeSerializer('unwrap', [canSymbol.for('can.unwrap')]),
+ serialize: makeSerializer('serialize', [
+ canSymbol.for('can.serialize'),
+ canSymbol.for('can.unwrap')
+ ]),
+ assignMap: function (target, source) {
+ var hasOwnKey = fastHasOwnKey(target);
+ var getKeyValue = target[getKeyValueSymbol] || shiftedGetKeyValue;
+ var setKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
+ this.eachKey(source, function (value, key) {
+ if (!hasOwnKey(key) || getKeyValue.call(target, key) !== value) {
+ setKeyValue.call(target, key, value);
+ }
+ });
+ return target;
+ },
+ assignList: function (target, source) {
+ var inserting = this.toArray(source);
+ getSetReflections.splice(target, 0, inserting, inserting);
+ return target;
+ },
+ assign: function (target, source) {
+ if (typeReflections.isIteratorLike(source) || typeReflections.isMoreListLikeThanMapLike(source)) {
+ this.assignList(target, source);
+ } else {
+ this.assignMap(target, source);
+ }
+ return target;
+ },
+ assignDeepMap: function (target, source) {
+ var hasOwnKey = fastHasOwnKey(target);
+ var getKeyValue = target[getKeyValueSymbol] || shiftedGetKeyValue;
+ var setKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
+ this.eachKey(source, function (newVal, key) {
+ if (!hasOwnKey(key)) {
+ getSetReflections.setKeyValue(target, key, newVal);
+ } else {
+ var curVal = getKeyValue.call(target, key);
+ if (newVal === curVal) {
+ } else if (typeReflections.isPrimitive(curVal) || typeReflections.isPrimitive(newVal) || shouldUpdateOrAssign(curVal) === false) {
+ setKeyValue.call(target, key, newVal);
+ } else {
+ this.assignDeep(curVal, newVal);
+ }
+ }
+ }, this);
+ return target;
+ },
+ assignDeepList: function (target, source) {
+ return updateDeepList.call(this, target, source, true);
+ },
+ assignDeep: function (target, source) {
+ var assignDeep = target[canSymbol.for('can.assignDeep')];
+ if (assignDeep) {
+ assignDeep.call(target, source);
+ } else if (typeReflections.isMoreListLikeThanMapLike(source)) {
+ this.assignDeepList(target, source);
+ } else {
+ this.assignDeepMap(target, source);
+ }
+ return target;
+ },
+ updateMap: function (target, source) {
+ var sourceKeyMap = makeMap(this.getOwnEnumerableKeys(source));
+ var sourceGetKeyValue = source[getKeyValueSymbol] || shiftedGetKeyValue;
+ var targetSetKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
+ this.eachKey(target, function (curVal, key) {
+ if (!sourceKeyMap.get(key)) {
+ getSetReflections.deleteKeyValue(target, key);
+ return;
+ }
+ sourceKeyMap.set(key, false);
+ var newVal = sourceGetKeyValue.call(source, key);
+ if (newVal !== curVal) {
+ targetSetKeyValue.call(target, key, newVal);
+ }
+ }, this);
+ this.eachIndex(sourceKeyMap.keys(), function (key) {
+ if (sourceKeyMap.get(key)) {
+ targetSetKeyValue.call(target, key, sourceGetKeyValue.call(source, key));
+ }
+ });
+ return target;
+ },
+ updateList: function (target, source) {
+ var inserting = this.toArray(source);
+ getSetReflections.splice(target, 0, target, inserting);
+ return target;
+ },
+ update: function (target, source) {
+ if (typeReflections.isIteratorLike(source) || typeReflections.isMoreListLikeThanMapLike(source)) {
+ this.updateList(target, source);
+ } else {
+ this.updateMap(target, source);
+ }
+ return target;
+ },
+ updateDeepMap: function (target, source) {
+ var sourceKeyMap = makeMap(this.getOwnEnumerableKeys(source));
+ var sourceGetKeyValue = source[getKeyValueSymbol] || shiftedGetKeyValue;
+ var targetSetKeyValue = target[setKeyValueSymbol] || shiftedSetKeyValue;
+ this.eachKey(target, function (curVal, key) {
+ if (!sourceKeyMap.get(key)) {
+ getSetReflections.deleteKeyValue(target, key);
+ return;
+ }
+ sourceKeyMap.set(key, false);
+ var newVal = sourceGetKeyValue.call(source, key);
+ if (typeReflections.isPrimitive(curVal) || typeReflections.isPrimitive(newVal) || shouldUpdateOrAssign(curVal) === false) {
+ targetSetKeyValue.call(target, key, newVal);
+ } else {
+ this.updateDeep(curVal, newVal);
+ }
+ }, this);
+ this.eachIndex(sourceKeyMap.keys(), function (key) {
+ if (sourceKeyMap.get(key)) {
+ targetSetKeyValue.call(target, key, sourceGetKeyValue.call(source, key));
+ }
+ });
+ return target;
+ },
+ updateDeepList: function (target, source) {
+ return updateDeepList.call(this, target, source);
+ },
+ updateDeep: function (target, source) {
+ var updateDeep = target[canSymbol.for('can.updateDeep')];
+ if (updateDeep) {
+ updateDeep.call(target, source);
+ } else if (typeReflections.isMoreListLikeThanMapLike(source)) {
+ this.updateDeepList(target, source);
+ } else {
+ this.updateDeepMap(target, source);
+ }
+ return target;
+ },
+ 'in': function () {
+ },
+ getAllEnumerableKeys: function () {
+ },
+ getAllKeys: function () {
+ },
+ assignSymbols: function (target, source) {
+ this.eachKey(source, function (value, key) {
+ var symbol = typeReflections.isSymbolLike(canSymbol[key]) ? canSymbol[key] : canSymbol.for(key);
+ getSetReflections.setKeyValue(target, symbol, value);
+ });
+ return target;
+ },
+ isSerializable: isSerializable,
+ size: function (obj) {
+ var size = obj[sizeSymbol];
+ var count = 0;
+ if (size) {
+ return size.call(obj);
+ } else if (helpers.hasLength(obj)) {
+ return obj.length;
+ } else if (typeReflections.isListLike(obj)) {
+ this.each(obj, function () {
+ count++;
+ });
+ return count;
+ } else if (obj) {
+ for (var prop in obj) {
+ if (obj.hasOwnProperty(prop)) {
+ count++;
+ }
+ }
+ return count;
+ } else {
+ return undefined;
+ }
+ },
+ defineInstanceKey: function (cls, key, properties) {
+ var defineInstanceKey = cls[canSymbol.for('can.defineInstanceKey')];
+ if (defineInstanceKey) {
+ return defineInstanceKey.call(cls, key, properties);
+ }
+ var proto = cls.prototype;
+ defineInstanceKey = proto[canSymbol.for('can.defineInstanceKey')];
+ if (defineInstanceKey) {
+ defineInstanceKey.call(proto, key, properties);
+ } else {
+ Object.defineProperty(proto, key, shapeReflections.assign({
+ configurable: true,
+ enumerable: !typeReflections.isSymbolLike(key),
+ writable: true
+ }, properties));
+ }
+ }
+ };
+ shapeReflections.keys = shapeReflections.getOwnEnumerableKeys;
+ module.exports = shapeReflections;
+});
+/*can-reflect@1.10.2#reflections/get-name/get-name*/
+define('can-reflect/reflections/get-name/get-name', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-symbol',
+ 'can-reflect/reflections/type/type'
+], function (require, exports, module) {
+ var canSymbol = require('can-symbol');
+ var typeReflections = require('can-reflect/reflections/type/type');
+ var getNameSymbol = canSymbol.for('can.getName');
+ function setName(obj, nameGetter) {
+ if (typeof nameGetter !== 'function') {
+ var value = nameGetter;
+ nameGetter = function () {
+ return value;
+ };
+ }
+ Object.defineProperty(obj, getNameSymbol, { value: nameGetter });
+ }
+ function getName(obj) {
+ var nameGetter = obj[getNameSymbol];
+ if (nameGetter) {
+ return nameGetter.call(obj);
+ }
+ if (typeof obj === 'function') {
+ return obj.name;
+ }
+ if (obj.constructor && obj !== obj.constructor) {
+ var parent = getName(obj.constructor);
+ if (parent) {
+ if (typeReflections.isValueLike(obj)) {
+ return parent + '<>';
+ }
+ if (typeReflections.isMoreListLikeThanMapLike(obj)) {
+ return parent + '[]';
+ }
+ if (typeReflections.isMapLike(obj)) {
+ return parent + '{}';
+ }
+ }
+ }
+ return undefined;
+ }
+ module.exports = {
+ setName: setName,
+ getName: getName
+ };
+});
+/*can-reflect@1.10.2#types/map*/
+define('can-reflect/types/map', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-reflect/reflections/shape/shape',
+ 'can-symbol'
+], function (require, exports, module) {
+ var shape = require('can-reflect/reflections/shape/shape');
+ var CanSymbol = require('can-symbol');
+ function keysPolyfill() {
+ var keys = [];
+ var currentIndex = 0;
+ this.forEach(function (val, key) {
+ keys.push(key);
+ });
+ return {
+ next: function () {
+ return {
+ value: keys[currentIndex],
+ done: currentIndex++ === keys.length
+ };
+ }
+ };
+ }
+ if (typeof Map !== 'undefined') {
+ shape.assignSymbols(Map.prototype, {
+ 'can.getOwnEnumerableKeys': Map.prototype.keys,
+ 'can.setKeyValue': Map.prototype.set,
+ 'can.getKeyValue': Map.prototype.get,
+ 'can.deleteKeyValue': Map.prototype['delete'],
+ 'can.hasOwnKey': Map.prototype.has
+ });
+ if (typeof Map.prototype.keys !== 'function') {
+ Map.prototype.keys = Map.prototype[CanSymbol.for('can.getOwnEnumerableKeys')] = keysPolyfill;
+ }
+ }
+ if (typeof WeakMap !== 'undefined') {
+ shape.assignSymbols(WeakMap.prototype, {
+ 'can.getOwnEnumerableKeys': function () {
+ throw new Error('can-reflect: WeakMaps do not have enumerable keys.');
+ },
+ 'can.setKeyValue': WeakMap.prototype.set,
+ 'can.getKeyValue': WeakMap.prototype.get,
+ 'can.deleteKeyValue': WeakMap.prototype['delete'],
+ 'can.hasOwnKey': WeakMap.prototype.has
+ });
+ }
+});
+/*can-reflect@1.10.2#types/set*/
+define('can-reflect/types/set', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-reflect/reflections/shape/shape',
+ 'can-symbol'
+], function (require, exports, module) {
+ var shape = require('can-reflect/reflections/shape/shape');
+ var CanSymbol = require('can-symbol');
+ if (typeof Set !== 'undefined') {
+ shape.assignSymbols(Set.prototype, {
+ 'can.isMoreListLikeThanMapLike': true,
+ 'can.updateValues': function (index, removing, adding) {
+ if (removing !== adding) {
+ shape.each(removing, function (value) {
+ this.delete(value);
+ }, this);
+ }
+ shape.each(adding, function (value) {
+ this.add(value);
+ }, this);
+ },
+ 'can.size': function () {
+ return this.size;
+ }
+ });
+ if (typeof Set.prototype[CanSymbol.iterator] !== 'function') {
+ Set.prototype[CanSymbol.iterator] = function () {
+ var arr = [];
+ var currentIndex = 0;
+ this.forEach(function (val) {
+ arr.push(val);
+ });
+ return {
+ next: function () {
+ return {
+ value: arr[currentIndex],
+ done: currentIndex++ === arr.length
+ };
+ }
+ };
+ };
+ }
+ }
+ if (typeof WeakSet !== 'undefined') {
+ shape.assignSymbols(WeakSet.prototype, {
+ 'can.isListLike': true,
+ 'can.isMoreListLikeThanMapLike': true,
+ 'can.updateValues': function (index, removing, adding) {
+ if (removing !== adding) {
+ shape.each(removing, function (value) {
+ this.delete(value);
+ }, this);
+ }
+ shape.each(adding, function (value) {
+ this.add(value);
+ }, this);
+ },
+ 'can.size': function () {
+ throw new Error('can-reflect: WeakSets do not have enumerable keys.');
+ }
+ });
+ }
+});
+/*can-reflect@1.10.2#can-reflect*/
+define('can-reflect', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-reflect/reflections/call/call',
+ 'can-reflect/reflections/get-set/get-set',
+ 'can-reflect/reflections/observe/observe',
+ 'can-reflect/reflections/shape/shape',
+ 'can-reflect/reflections/type/type',
+ 'can-reflect/reflections/get-name/get-name',
+ 'can-namespace',
+ 'can-reflect/types/map',
+ 'can-reflect/types/set'
+], function (require, exports, module) {
+ var functionReflections = require('can-reflect/reflections/call/call');
+ var getSet = require('can-reflect/reflections/get-set/get-set');
+ var observe = require('can-reflect/reflections/observe/observe');
+ var shape = require('can-reflect/reflections/shape/shape');
+ var type = require('can-reflect/reflections/type/type');
+ var getName = require('can-reflect/reflections/get-name/get-name');
+ var namespace = require('can-namespace');
+ var reflect = {};
+ [
+ functionReflections,
+ getSet,
+ observe,
+ shape,
+ type,
+ getName
+ ].forEach(function (reflections) {
+ for (var prop in reflections) {
+ reflect[prop] = reflections[prop];
+ }
+ });
+ require('can-reflect/types/map');
+ require('can-reflect/types/set');
+ module.exports = namespace.Reflect = reflect;
+});
+/*can-types@1.1.5#can-types*/
+define('can-types', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace',
+ 'can-reflect',
+ 'can-symbol',
+ 'can-log/dev/dev'
+], function (require, exports, module) {
+ var namespace = require('can-namespace');
+ var canReflect = require('can-reflect');
+ var canSymbol = require('can-symbol');
+ var dev = require('can-log/dev/dev');
+ var types = {
+ isMapLike: function (obj) {
+ return canReflect.isObservableLike(obj) && canReflect.isMapLike(obj);
+ },
+ isListLike: function (obj) {
+ return canReflect.isObservableLike(obj) && canReflect.isListLike(obj);
+ },
+ isPromise: function (obj) {
+ return canReflect.isPromise(obj);
+ },
+ isConstructor: function (func) {
+ return canReflect.isConstructorLike(func);
+ },
+ isCallableForValue: function (obj) {
+ return obj && canReflect.isFunctionLike(obj) && !canReflect.isConstructorLike(obj);
+ },
+ isCompute: function (obj) {
+ return obj && obj.isComputed;
+ },
+ get iterator() {
+ return canSymbol.iterator || canSymbol.for('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-cid@1.1.2#can-cid*/
+define('can-cid', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace'
+], function (require, exports, module) {
+ var namespace = require('can-namespace');
+ var _cid = 0;
+ var domExpando = 'can' + new Date();
+ var cid = function (object, name) {
+ var propertyName = object.nodeName ? domExpando : '_cid';
+ if (!object[propertyName]) {
+ _cid++;
+ object[propertyName] = (name || '') + _cid;
+ }
+ return object[propertyName];
+ };
+ cid.domExpando = domExpando;
+ cid.get = function (object) {
+ var type = typeof object;
+ var isObject = type !== null && (type === 'object' || type === 'function');
+ return isObject ? cid(object) : type + ':' + object;
+ };
+ 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-dom-data-state@0.2.0#can-dom-data-state*/
+define('can-dom-data-state', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace',
+ 'can-cid'
+], function (require, exports, module) {
+ 'use strict';
+ var namespace = require('can-namespace');
+ var CID = require('can-cid');
+ var data = {};
+ var isEmptyObject = function (obj) {
+ for (var prop in obj) {
+ return false;
+ }
+ return true;
+ };
+ var setData = function (name, value) {
+ var id = CID(this);
+ var store = data[id] || (data[id] = {});
+ if (name !== undefined) {
+ store[name] = value;
+ }
+ return store;
+ };
+ var deleteNode = function () {
+ var id = CID.get(this);
+ var nodeDeleted = false;
+ if (id && data[id]) {
+ nodeDeleted = true;
+ delete data[id];
+ }
+ return nodeDeleted;
+ };
+ var domDataState = {
+ _data: data,
+ getCid: function () {
+ return CID.get(this);
+ },
+ cid: function () {
+ return CID(this);
+ },
+ expando: CID.domExpando,
+ get: function (key) {
+ var id = CID.get(this), store = id && data[id];
+ return key === undefined ? store : store && store[key];
+ },
+ set: setData,
+ clean: function (prop) {
+ var id = CID.get(this);
+ var itemData = data[id];
+ if (itemData && itemData[prop]) {
+ delete itemData[prop];
+ }
+ if (isEmptyObject(itemData)) {
+ deleteNode.call(this);
+ }
+ },
+ delete: deleteNode
+ };
+ if (namespace.domDataState) {
+ throw new Error('You can\'t have two versions of can-dom-data-state, check your dependencies');
+ } else {
+ module.exports = namespace.domDataState = domDataState;
+ }
+});
+/*can-globals@0.3.0#can-globals-proto*/
+define('can-globals/can-globals-proto', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-reflect'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var canReflect = require('can-reflect');
+ function dispatch(key) {
+ var handlers = this.eventHandlers[key];
+ if (handlers) {
+ var handlersCopy = handlers.slice();
+ var value = this.getKeyValue(key);
+ for (var i = 0; i < handlersCopy.length; i++) {
+ handlersCopy[i](value);
+ }
+ }
+ }
+ function Globals() {
+ this.eventHandlers = {};
+ this.properties = {};
+ }
+ Globals.prototype.define = function (key, value, enableCache) {
+ if (enableCache === undefined) {
+ enableCache = true;
+ }
+ if (!this.properties[key]) {
+ this.properties[key] = {
+ default: value,
+ value: value,
+ enableCache: enableCache
+ };
+ }
+ return this;
+ };
+ Globals.prototype.getKeyValue = function (key) {
+ var property = this.properties[key];
+ if (property) {
+ if (typeof property.value === 'function') {
+ if (property.cachedValue) {
+ return property.cachedValue;
+ }
+ if (property.enableCache) {
+ property.cachedValue = property.value();
+ return property.cachedValue;
+ } else {
+ return property.value();
+ }
+ }
+ return property.value;
+ }
+ };
+ Globals.prototype.makeExport = function (key) {
+ return function (value) {
+ if (arguments.length === 0) {
+ return this.getKeyValue(key);
+ }
+ if (typeof value === 'undefined' || value === null) {
+ this.deleteKeyValue(key);
+ } else {
+ if (typeof value === 'function') {
+ this.setKeyValue(key, function () {
+ return value;
+ });
+ } else {
+ this.setKeyValue(key, value);
+ }
+ return value;
+ }
+ }.bind(this);
+ };
+ Globals.prototype.offKeyValue = function (key, handler) {
+ if (this.properties[key]) {
+ var handlers = this.eventHandlers[key];
+ if (handlers) {
+ var i = handlers.indexOf(handler);
+ handlers.splice(i, 1);
+ }
+ }
+ return this;
+ };
+ Globals.prototype.onKeyValue = function (key, handler) {
+ if (this.properties[key]) {
+ if (!this.eventHandlers[key]) {
+ this.eventHandlers[key] = [];
+ }
+ this.eventHandlers[key].push(handler);
+ }
+ return this;
+ };
+ Globals.prototype.deleteKeyValue = function (key) {
+ var property = this.properties[key];
+ if (property !== undefined) {
+ property.value = property.default;
+ property.cachedValue = undefined;
+ dispatch.call(this, key);
+ }
+ return this;
+ };
+ Globals.prototype.setKeyValue = function (key, value) {
+ if (!this.properties[key]) {
+ return this.define(key, value);
+ }
+ var property = this.properties[key];
+ property.value = value;
+ property.cachedValue = undefined;
+ dispatch.call(this, key);
+ return this;
+ };
+ Globals.prototype.reset = function () {
+ for (var key in this.properties) {
+ if (this.properties.hasOwnProperty(key)) {
+ this.properties[key].value = this.properties[key].default;
+ this.properties[key].cachedValue = undefined;
+ dispatch.call(this, key);
+ }
+ }
+ return this;
+ };
+ canReflect.assignSymbols(Globals.prototype, {
+ 'can.getKeyValue': Globals.prototype.getKeyValue,
+ 'can.setKeyValue': Globals.prototype.setKeyValue,
+ 'can.deleteKeyValue': Globals.prototype.deleteKeyValue,
+ 'can.onKeyValue': Globals.prototype.onKeyValue,
+ 'can.offKeyValue': Globals.prototype.offKeyValue
+ });
+ module.exports = Globals;
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-globals@0.3.0#can-globals-instance*/
+define('can-globals/can-globals-instance', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace',
+ 'can-globals/can-globals-proto'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var namespace = require('can-namespace');
+ var Globals = require('can-globals/can-globals-proto');
+ var globals = new Globals();
+ if (namespace.globals) {
+ throw new Error('You can\'t have two versions of can-globals, check your dependencies');
+ } else {
+ module.exports = namespace.globals = globals;
+ }
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-globals@0.3.0#global/global*/
+define('can-globals/global/global', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/can-globals-instance'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var globals = require('can-globals/can-globals-instance');
+ globals.define('global', function () {
+ return typeof WorkerGlobalScope !== 'undefined' && self instanceof WorkerGlobalScope ? self : typeof process === 'object' && {}.toString.call(process) === '[object process]' ? global : window;
+ });
+ module.exports = globals.makeExport('global');
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-globals@0.3.0#document/document*/
+define('can-globals/document/document', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/global/global',
+ 'can-globals/can-globals-instance'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ require('can-globals/global/global');
+ var globals = require('can-globals/can-globals-instance');
+ globals.define('document', function () {
+ return globals.getKeyValue('global').document;
+ });
+ module.exports = globals.makeExport('document');
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-globals@0.3.0#mutation-observer/mutation-observer*/
+define('can-globals/mutation-observer/mutation-observer', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/global/global',
+ 'can-globals/can-globals-instance'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ require('can-globals/global/global');
+ var globals = require('can-globals/can-globals-instance');
+ globals.define('MutationObserver', function () {
+ var GLOBAL = globals.getKeyValue('global');
+ return GLOBAL.MutationObserver || GLOBAL.WebKitMutationObserver || GLOBAL.MozMutationObserver;
+ });
+ module.exports = globals.makeExport('MutationObserver');
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-cid@1.1.2#helpers*/
+define('can-cid/helpers', function (require, exports, module) {
+ module.exports = {
+ each: function (obj, cb, context) {
+ for (var prop in obj) {
+ cb.call(context, obj[prop], prop);
+ }
+ return obj;
+ }
+ };
+});
+/*can-cid@1.1.2#set/set*/
+define('can-cid/set/set', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-cid',
+ 'can-cid/helpers'
+], function (require, exports, module) {
+ 'use strict';
+ var getCID = require('can-cid').get;
+ var helpers = require('can-cid/helpers');
+ var CIDSet;
+ if (typeof Set !== 'undefined') {
+ CIDSet = 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) {
+ helpers.each(this.values, cb, thisArg);
+ };
+ CIDSet.prototype.has = function (value) {
+ return getCID(value) in this.values;
+ };
+ CIDSet.prototype.clear = function () {
+ return this.values = {};
+ };
+ Object.defineProperty(CIDSet.prototype, 'size', {
+ get: function () {
+ var size = 0;
+ helpers.each(this.values, function () {
+ size++;
+ });
+ return size;
+ }
+ });
+ }
+ module.exports = CIDSet;
+});
+/*can-util@3.10.18#dom/mutation-observer/document/document*/
+define('can-util/dom/mutation-observer/document/document', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/document/document',
+ 'can-dom-data-state',
+ 'can-globals/mutation-observer/mutation-observer',
+ 'can-util/js/each/each',
+ 'can-cid/set/set',
+ 'can-util/js/make-array/make-array',
+ 'can-util/js/string/string'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var getDocument = require('can-globals/document/document');
+ var domDataState = require('can-dom-data-state');
+ var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
+ var each = require('can-util/js/each/each');
+ var CIDStore = require('can-cid/set/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 = getMutationObserver();
+ if (MO) {
+ var documentElement = getDocument().documentElement;
+ var globalObserverData = domDataState.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: []
+ };
+ domDataState.set.call(documentElement, 'globalObserverData', globalObserverData);
+ }
+ globalObserverData.handlers.push(handler);
+ }
+ },
+ remove: function (handler) {
+ var documentElement = getDocument().documentElement;
+ var globalObserverData = domDataState.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();
+ domDataState.clean.call(documentElement, 'globalObserverData');
+ }
+ }
+ }
+ };
+ var makeMutationMethods = function (name) {
+ var mutationName = name.toLowerCase() + 'Nodes';
+ var getMutationData = function () {
+ var documentElement = getDocument().documentElement;
+ var mutationData = domDataState.get.call(documentElement, mutationName + 'MutationData');
+ if (!mutationData) {
+ mutationData = {
+ name: mutationName,
+ handlers: [],
+ afterHandlers: [],
+ hander: null
+ };
+ if (getMutationObserver()) {
+ domDataState.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);
+ domDataState.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;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/data/data*/
+define('can-util/dom/data/data', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-dom-data-state',
+ 'can-util/dom/mutation-observer/document/document'
+], function (require, exports, module) {
+ 'use strict';
+ var domDataState = require('can-dom-data-state');
+ var mutationDocument = require('can-util/dom/mutation-observer/document/document');
+ var elementSetCount = 0;
+ var deleteNode = function () {
+ elementSetCount -= 1;
+ return domDataState.delete.call(this);
+ };
+ var cleanupDomData = function (node) {
+ if (domDataState.get.call(node) !== undefined) {
+ deleteNode.call(node);
+ }
+ if (elementSetCount === 0) {
+ mutationDocument.offAfterRemovedNodes(cleanupDomData);
+ }
+ };
+ module.exports = {
+ getCid: domDataState.getCid,
+ cid: domDataState.cid,
+ expando: domDataState.expando,
+ clean: domDataState.clean,
+ get: domDataState.get,
+ set: function (name, value) {
+ if (elementSetCount === 0) {
+ mutationDocument.onAfterRemovedNodes(cleanupDomData);
+ }
+ elementSetCount += domDataState.get.call(this) ? 0 : 1;
+ domDataState.set.call(this, name, value);
+ },
+ delete: deleteNode,
+ _getElementSetCount: function () {
+ return elementSetCount;
+ }
+ };
+});
+/*can-util@3.10.18#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-globals@0.3.0#is-node/is-node*/
+define('can-globals/is-node/is-node', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/can-globals-instance'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var globals = require('can-globals/can-globals-instance');
+ globals.define('isNode', function () {
+ return typeof process === 'object' && {}.toString.call(process) === '[object process]';
+ });
+ module.exports = globals.makeExport('isNode');
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-globals@0.3.0#is-browser-window/is-browser-window*/
+define('can-globals/is-browser-window/is-browser-window', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/can-globals-instance',
+ 'can-globals/is-node/is-node'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var globals = require('can-globals/can-globals-instance');
+ require('can-globals/is-node/is-node');
+ globals.define('isBrowserWindow', function () {
+ var isNode = globals.getKeyValue('isNode');
+ return typeof window !== 'undefined' && typeof document !== 'undefined' && isNode === false;
+ });
+ module.exports = globals.makeExport('isBrowserWindow');
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/events/events*/
+define('can-util/dom/events/events', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/document/document',
+ 'can-globals/is-browser-window/is-browser-window',
+ 'can-util/js/is-plain-object/is-plain-object',
+ 'can-log/dev/dev'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var getDocument = require('can-globals/document/document');
+ var isBrowserWindow = require('can-globals/is-browser-window/is-browser-window');
+ var isPlainObject = require('can-util/js/is-plain-object/is-plain-object');
+ var fixSyntheticEventsOnDisabled = false;
+ var dev = require('can-log/dev/dev');
+ 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 ret;
+ var dispatchingOnDisabled = fixSyntheticEventsOnDisabled && isDispatchingOnDisabled(this, event);
+ var doc = this.ownerDocument || getDocument();
+ 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];
+ }
+ }
+ }
+ if (this.disabled === true && ev.type !== 'fix_synthetic_events_on_disabled_test') {
+ }
+ ev.args = args;
+ if (dispatchingOnDisabled) {
+ this.disabled = false;
+ }
+ ret = this.dispatchEvent(ev);
+ if (dispatchingOnDisabled) {
+ this.disabled = true;
+ }
+ return ret;
+ }
+ };
+ (function () {
+ if (!isBrowserWindow()) {
+ return;
+ }
+ var testEventName = 'fix_synthetic_events_on_disabled_test';
+ var input = document.createElement('input');
+ input.disabled = true;
+ var timer = setTimeout(function () {
+ fixSyntheticEventsOnDisabled = true;
+ }, 50);
+ var onTest = function onTest() {
+ clearTimeout(timer);
+ module.exports.removeEventListener.call(input, testEventName, onTest);
+ };
+ module.exports.addEventListener.call(input, testEventName, onTest);
+ try {
+ module.exports.dispatch.call(input, testEventName, [], false);
+ } catch (e) {
+ onTest();
+ fixSyntheticEventsOnDisabled = true;
+ }
+ }());
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#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.10.18#dom/dispatch/dispatch*/
+define('can-util/dom/dispatch/dispatch', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/events'
+], 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.10.18#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.10.18#dom/events/delegate/delegate*/
+define('can-util/dom/events/delegate/delegate', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/events',
+ 'can-util/dom/data/data',
+ 'can-util/dom/matches/matches',
+ 'can-util/js/each/each',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-cid'
+], 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 canCid = require('can-cid');
+ var dataName = 'delegateEvents';
+ var useCapture = function (eventType) {
+ return eventType === 'focus' || eventType === 'blur';
+ };
+ var handleEvent = function (overrideEventType, ev) {
+ var events = domData.get.call(this, dataName);
+ var eventTypeEvents = events[overrideEventType || 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] = {};
+ var delegateHandler = handleEvent.bind(this, eventType);
+ domData.set.call(this, canCid(handler), delegateHandler);
+ domEvents.addEventListener.call(this, eventType, delegateHandler, 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 && 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)) {
+ var delegateHandler = domData.get.call(this, canCid(handler));
+ domEvents.removeEventListener.call(this, eventType, delegateHandler, useCapture(eventType));
+ delete events[eventType];
+ if (isEmptyObject(events)) {
+ domData.clean.call(this, dataName);
+ }
+ }
+ }
+ }
+ };
+});
+/*can-util@3.10.18#js/single-reference/single-reference*/
+define('can-util/js/single-reference/single-reference', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-cid'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ var CID = require('can-cid');
+ var singleReference;
+ function getKeyName(key, extraKey) {
+ var keyName = extraKey ? CID(key) + ':' + extraKey : CID(key);
+ return keyName || key;
+ }
+ singleReference = {
+ set: function (obj, key, value, extraKey) {
+ obj[getKeyName(key, extraKey)] = value;
+ },
+ getAndDelete: function (obj, key, extraKey) {
+ var keyName = getKeyName(key, extraKey);
+ var value = obj[keyName];
+ delete obj[keyName];
+ return value;
+ }
+ };
+ module.exports = singleReference;
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#js/cid/get-cid*/
+define('can-util/js/cid/get-cid', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-cid',
+ 'can-dom-data-state'
+], function (require, exports, module) {
+ 'use strict';
+ var CID = require('can-cid');
+ var domDataState = require('can-dom-data-state');
+ module.exports = function (obj) {
+ if (typeof obj.nodeType === 'number') {
+ return domDataState.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.10.18#dom/events/delegate/enter-leave*/
+define('can-util/dom/events/delegate/enter-leave', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/events',
+ 'can-util/js/single-reference/single-reference',
+ 'can-util/js/cid/get-cid'
+], function (require, exports, module) {
+ 'use strict';
+ var domEvents = require('can-util/dom/events/events'), singleRef = require('can-util/js/single-reference/single-reference'), cid = require('can-util/js/cid/get-cid');
+ var eventMap = {
+ mouseenter: 'mouseover',
+ mouseleave: 'mouseout',
+ pointerenter: 'pointerover',
+ pointerleave: 'pointerout'
+ }, classMap = {
+ mouseenter: 'MouseEvent',
+ mouseleave: 'MouseEvent',
+ pointerenter: 'PointerEvent',
+ pointerleave: 'PointerEvent'
+ }, _addDelegateListener = domEvents.addDelegateListener, _removeDelegateListener = domEvents.removeDelegateListener;
+ domEvents.addDelegateListener = function (eventType, selector, handler) {
+ if (eventMap[eventType] !== undefined) {
+ var origHandler = handler, origType = eventType;
+ eventType = eventMap[eventType];
+ handler = function (event) {
+ var target = this, related = event.relatedTarget;
+ if (!related || related !== target && !target.contains(related)) {
+ var eventClass = classMap[origType];
+ if (eventClass === 'MouseEvent') {
+ var newEv = document.createEvent(eventClass);
+ newEv.initMouseEvent(origType, false, false, event.view, event.detail, event.screenX, event.screenY, event.clientX, event.clientY, event.ctrlKey, event.altKey, event.shiftKey, event.metaKey, event.button, event.relatedTarget);
+ event = newEv;
+ } else if (eventClass === 'PointerEvent') {
+ event = new PointerEvent(origType, event);
+ }
+ return origHandler.call(this, event);
+ }
+ };
+ singleRef.set(origHandler, cid(this) + eventType, handler);
+ }
+ _addDelegateListener.call(this, eventType, selector, handler);
+ };
+ domEvents.removeDelegateListener = function (eventType, selector, handler) {
+ if (eventMap[eventType] !== undefined) {
+ eventType = eventMap[eventType];
+ handler = singleRef.getAndDelete(handler, cid(this) + eventType);
+ }
+ _removeDelegateListener.call(this, eventType, selector, handler);
+ };
+});
+/*can-event@3.7.6#can-event*/
+define('can-event', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/events',
+ 'can-cid',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-util/dom/dispatch/dispatch',
+ 'can-namespace',
+ 'can-util/dom/events/delegate/delegate',
+ 'can-util/dom/events/delegate/enter-leave'
+], 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');
+ require('can-util/dom/events/delegate/enter-leave');
+ 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;
+ }
+ return events[eventName];
+ }
+ 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;
+ }
+ if (!arguments.length) {
+ for (var bindEvent in this.__bindEvents) {
+ if (bindEvent === '_lifecycleBindings') {
+ this.__bindEvents._lifecycleBindings = null;
+ } else if (this.__bindEvents.hasOwnProperty(bindEvent)) {
+ canEvent.removeEventListener.call(this, bindEvent);
+ }
+ }
+ 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.10.18#js/last/last*/
+define('can-util/js/last/last', function (require, exports, module) {
+ 'use strict';
+ module.exports = function (arr) {
+ return arr && arr[arr.length - 1];
+ };
+});
+/*can-util@3.10.18#js/log/log*/
+define('can-util/js/log/log', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-log'
+], function (require, exports, module) {
+ 'use strict';
+ module.exports = require('can-log');
+});
+/*can-event@3.7.6#batch/batch*/
+define('can-event/batch/batch', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-event',
+ 'can-util/js/last/last',
+ 'can-namespace',
+ 'can-types',
+ 'can-util/js/dev/dev',
+ 'can-util/js/log/log'
+], 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 canLog = require('can-util/js/log/log');
+ 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 () {
+ dispatchingQueues = true;
+ while (queues.length) {
+ var queue = queues[0];
+ var tasks = queue.tasks, callbacks = queue.callbacks;
+ canBatch.batchNum = queue.number;
+ var len = tasks.length;
+ while (queue.index < len) {
+ var task = tasks[queue.index++];
+ task[0].apply(task[1], task[2]);
+ }
+ if (!queue.batchEnded) {
+ queue.batchEnded = true;
+ canEvent.dispatchSync.call(canBatch, 'batchEnd', [queue.number]);
+ }
+ while (queue.callbacksIndex < callbacks.length) {
+ callbacks[queue.callbacksIndex++]();
+ }
+ if (!queue.complete) {
+ queue.complete = true;
+ canBatch.batchNum = undefined;
+ queues.shift();
+ }
+ }
+ dispatchingQueues = false;
+ },
+ dispatch: function (event, args) {
+ var item = this, handlers;
+ if (!item.__inSetup) {
+ event = typeof event === 'string' ? { type: event } : event;
+ if (event.batchNum) {
+ canBatch.batchNum = 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({});
+ }
+ }
+ };
+ Object.defineProperty(canBatch, 'debounce', {
+ enumerable: false,
+ value: function (handler) {
+ var that = null;
+ var args = null;
+ return function () {
+ if (!that) {
+ canEvent.addEventListener.call(canBatch, 'batchEnd', function listener() {
+ canEvent.removeEventListener.call(canBatch, 'batchEnd', listener);
+ handler.apply(that, args);
+ that = null;
+ args = null;
+ });
+ }
+ that = this;
+ args = arguments;
+ };
+ }
+ });
+ canEvent.flush = canBatch.flush;
+ canEvent.dispatch = canBatch.dispatch;
+ canBatch.trigger = function () {
+ canLog.warn('use canEvent.dispatch instead');
+ return canEvent.dispatch.apply(this, arguments);
+ };
+ canTypes.queueTask = canBatch.queue;
+ if (namespace.batch) {
+ throw new Error('You can\'t have two versions of can-event/batch/batch, check your dependencies');
+ } else {
+ module.exports = namespace.batch = canBatch;
+ }
+});
+/*can-cid@1.1.2#map/map*/
+define('can-cid/map/map', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-cid',
+ 'can-cid/helpers'
+], function (require, exports, module) {
+ 'use strict';
+ var getCID = require('can-cid').get;
+ var helpers = require('can-cid/helpers');
+ var CIDMap;
+ if (typeof Map !== 'undefined') {
+ CIDMap = Map;
+ } else {
+ var CIDMap = function () {
+ this.values = {};
+ };
+ CIDMap.prototype.set = function (key, value) {
+ this.values[getCID(key)] = {
+ key: key,
+ value: value
+ };
+ };
+ CIDMap.prototype['delete'] = function (key) {
+ var has = getCID(key) in this.values;
+ if (has) {
+ delete this.values[getCID(key)];
+ }
+ return has;
+ };
+ CIDMap.prototype.forEach = function (cb, thisArg) {
+ helpers.each(this.values, function (pair) {
+ return cb.call(thisArg || this, pair.value, pair.key, this);
+ }, this);
+ };
+ CIDMap.prototype.has = function (key) {
+ return getCID(key) in this.values;
+ };
+ CIDMap.prototype.get = function (key) {
+ var obj = this.values[getCID(key)];
+ return obj && obj.value;
+ };
+ CIDMap.prototype.clear = function () {
+ return this.values = {};
+ };
+ Object.defineProperty(CIDMap.prototype, 'size', {
+ get: function () {
+ var size = 0;
+ helpers.each(this.values, function () {
+ size++;
+ });
+ return size;
+ }
+ });
+ }
+ module.exports = CIDMap;
+});
+/*can-util@3.10.18#js/cid-map/cid-map*/
+define('can-util/js/cid-map/cid-map', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-cid/map/map'
+], function (require, exports, module) {
+ 'use strict';
+ module.exports = require('can-cid/map/map');
+});
+/*can-util@3.10.18#js/cid-set/cid-set*/
+define('can-util/js/cid-set/cid-set', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-cid/set/set'
+], function (require, exports, module) {
+ 'use strict';
+ module.exports = require('can-cid/set/set');
+});
+/*can-observation@3.3.6#can-observation*/
+define('can-observation', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-event',
+ 'can-event',
+ 'can-event/batch/batch',
+ 'can-util/js/assign/assign',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-namespace',
+ 'can-util/js/log/log',
+ 'can-reflect',
+ 'can-symbol',
+ 'can-cid',
+ 'can-util/js/cid-map/cid-map',
+ 'can-util/js/cid-set/cid-set'
+], function (require, exports, module) {
+ (function (global, 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 isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
+ var namespace = require('can-namespace');
+ var canLog = require('can-util/js/log/log');
+ var canReflect = require('can-reflect');
+ var canSymbol = require('can-symbol');
+ var CID = require('can-cid');
+ var CIDMap = require('can-util/js/cid-map/cid-map');
+ var CIDSet = require('can-util/js/cid-set/cid-set');
+ function Observation(func, context, compute) {
+ this.newObserved = {};
+ this.oldObserved = null;
+ this.func = func;
+ this.context = context;
+ this.compute = compute && (compute.updater || 'isObservable' in compute) ? compute : { updater: compute };
+ this.isObservable = typeof compute === 'object' ? compute.isObservable : true;
+ var observation = this;
+ this.onDependencyChange = function (value, legacyValue) {
+ observation.dependencyChange(this, value, legacyValue);
+ };
+ this.ignore = 0;
+ this.needsUpdate = false;
+ this.handlers = null;
+ CID(this);
+ }
+ var observationStack = [];
+ Observation.observationStack = observationStack;
+ var remaining = {
+ updates: 0,
+ notifications: 0
+ };
+ Observation.remaining = remaining;
+ assign(Observation.prototype, {
+ get: function () {
+ if (this.isObservable && Observation.isRecording()) {
+ Observation.add(this);
+ if (!this.bound) {
+ Observation.temporarilyBind(this);
+ }
+ }
+ if (this.bound === true) {
+ canEvent.flush();
+ if (remaining.updates > 0) {
+ Observation.updateChildrenAndSelf(this);
+ }
+ return this.value;
+ } else {
+ return this.func.call(this.context);
+ }
+ },
+ getPrimaryDepth: function () {
+ return this.compute._primaryDepth || 0;
+ },
+ addEdge: function (objEv) {
+ if (objEv.event === 'undefined') {
+ canReflect.onValue(objEv.obj, this.onDependencyChange);
+ } else {
+ canReflect.onKeyValue(objEv.obj, objEv.event, this.onDependencyChange);
+ }
+ },
+ removeEdge: function (objEv) {
+ if (objEv.event === 'undefined') {
+ canReflect.offValue(objEv.obj, this.onDependencyChange);
+ } else {
+ canReflect.offKeyValue(objEv.obj, objEv.event, this.onDependencyChange);
+ }
+ },
+ dependencyChange: function () {
+ if (this.bound === true) {
+ if (canBatch.batchNum === undefined || canBatch.batchNum !== this.batchNum) {
+ Observation.registerUpdate(this, canBatch.batchNum);
+ this.batchNum = canBatch.batchNum;
+ }
+ }
+ },
+ onDependencyChange: function (value) {
+ this.dependencyChange(value);
+ },
+ update: function (batchNum) {
+ if (this.needsUpdate === true) {
+ remaining.updates--;
+ }
+ this.needsUpdate = false;
+ if (this.bound === true) {
+ var oldValue = this.value;
+ this.oldValue = null;
+ this.start();
+ if (oldValue !== this.value) {
+ this.compute.updater(this.value, oldValue, batchNum);
+ return true;
+ }
+ }
+ },
+ getValueAndBind: function () {
+ canLog.warn('can-observation: call start instead of getValueAndBind');
+ return this.start();
+ },
+ start: function () {
+ this.bound = true;
+ this.oldObserved = this.newObserved || {};
+ this.ignore = 0;
+ this.newObserved = {};
+ observationStack.push(this);
+ this.value = this.func.call(this.context);
+ observationStack.pop();
+ this.updateBindings();
+ },
+ updateBindings: function () {
+ var newObserved = this.newObserved, oldObserved = this.oldObserved, name, obEv;
+ for (name in newObserved) {
+ obEv = newObserved[name];
+ if (!oldObserved[name]) {
+ this.addEdge(obEv);
+ } else {
+ oldObserved[name] = undefined;
+ }
+ }
+ for (name in oldObserved) {
+ obEv = oldObserved[name];
+ if (obEv !== undefined) {
+ this.removeEdge(obEv);
+ }
+ }
+ },
+ teardown: function () {
+ canLog.warn('can-observation: call stop instead of teardown');
+ return this.stop();
+ },
+ stop: function () {
+ this.bound = false;
+ for (var name in this.newObserved) {
+ var ob = this.newObserved[name];
+ this.removeEdge(ob);
+ }
+ this.newObserved = {};
+ }
+ });
+ var updateOrder = [], curPrimaryDepth = Infinity, maxPrimaryDepth = 0, currentBatchNum, isUpdating = false;
+ var updateUpdateOrder = function (observation) {
+ var primaryDepth = observation.getPrimaryDepth();
+ if (primaryDepth < curPrimaryDepth) {
+ curPrimaryDepth = primaryDepth;
+ }
+ if (primaryDepth > maxPrimaryDepth) {
+ maxPrimaryDepth = primaryDepth;
+ }
+ var primary = updateOrder[primaryDepth] || (updateOrder[primaryDepth] = []);
+ return primary;
+ };
+ Observation.registerUpdate = function (observation, batchNum) {
+ if (observation.needsUpdate === true) {
+ return;
+ }
+ remaining.updates++;
+ observation.needsUpdate = true;
+ var objs = updateUpdateOrder(observation);
+ objs.push(observation);
+ };
+ var afterCallbacks = [];
+ Observation.updateAndNotify = function (ev, batchNum) {
+ currentBatchNum = batchNum;
+ if (isUpdating === true) {
+ return;
+ }
+ isUpdating = true;
+ while (true) {
+ if (curPrimaryDepth <= maxPrimaryDepth) {
+ var primary = updateOrder[curPrimaryDepth];
+ var lastUpdate = primary && primary.pop();
+ if (lastUpdate !== undefined) {
+ lastUpdate.update(currentBatchNum);
+ } else {
+ curPrimaryDepth++;
+ }
+ } else {
+ updateOrder = [];
+ curPrimaryDepth = Infinity;
+ maxPrimaryDepth = 0;
+ isUpdating = false;
+ var afterCB = afterCallbacks;
+ afterCallbacks = [];
+ afterCB.forEach(function (cb) {
+ cb();
+ });
+ return;
+ }
+ }
+ };
+ canEvent.addEventListener.call(canBatch, 'batchEnd', Observation.updateAndNotify);
+ Observation.afterUpdateAndNotify = function (callback) {
+ canBatch.after(function () {
+ if (isUpdating === true) {
+ afterCallbacks.push(callback);
+ } else {
+ callback();
+ }
+ });
+ };
+ Observation.updateChildrenAndSelf = function (observation) {
+ if (observation.needsUpdate === true) {
+ return Observation.unregisterAndUpdate(observation);
+ }
+ var childHasChanged = false;
+ for (var prop in observation.newObserved) {
+ if (observation.newObserved[prop].obj.observation) {
+ if (Observation.updateChildrenAndSelf(observation.newObserved[prop].obj.observation)) {
+ childHasChanged = true;
+ }
+ }
+ }
+ if (childHasChanged === true) {
+ return observation.update(currentBatchNum);
+ }
+ };
+ Observation.unregisterAndUpdate = function (observation) {
+ var primaryDepth = observation.getPrimaryDepth();
+ var primary = updateOrder[primaryDepth];
+ if (primary !== undefined) {
+ var index = primary.indexOf(observation);
+ if (index !== -1) {
+ primary.splice(index, 1);
+ }
+ }
+ return observation.update(currentBatchNum);
+ };
+ Observation.add = function (obj, event) {
+ var top = observationStack[observationStack.length - 1];
+ if (top !== undefined && !top.ignore) {
+ var evStr = event + '', name = obj._cid + '|' + evStr;
+ if (top.traps !== undefined) {
+ top.traps.push({
+ obj: obj,
+ event: evStr,
+ name: name
+ });
+ } else {
+ top.newObserved[name] = {
+ obj: obj,
+ event: evStr
+ };
+ }
+ }
+ };
+ Observation.addAll = function (observes) {
+ var top = observationStack[observationStack.length - 1];
+ if (top !== undefined) {
+ if (top.traps !== undefined) {
+ top.traps.push.apply(top.traps, observes);
+ } else {
+ for (var i = 0, len = observes.length; i < len; i++) {
+ var trap = observes[i], name = trap.name;
+ if (top.newObserved[name] === undefined) {
+ top.newObserved[name] = trap;
+ }
+ }
+ }
+ }
+ };
+ Observation.ignore = function (fn) {
+ return function () {
+ if (observationStack.length > 0) {
+ var top = observationStack[observationStack.length - 1];
+ top.ignore++;
+ var res = fn.apply(this, arguments);
+ top.ignore--;
+ return res;
+ } else {
+ return fn.apply(this, arguments);
+ }
+ };
+ };
+ Observation.trap = function () {
+ if (observationStack.length > 0) {
+ var top = observationStack[observationStack.length - 1];
+ var oldTraps = top.traps;
+ var traps = top.traps = [];
+ return function () {
+ top.traps = oldTraps;
+ return traps;
+ };
+ } else {
+ return function () {
+ return [];
+ };
+ }
+ };
+ Observation.trapsCount = function () {
+ if (observationStack.length > 0) {
+ var top = observationStack[observationStack.length - 1];
+ return top.traps.length;
+ } else {
+ return 0;
+ }
+ };
+ Observation.isRecording = function () {
+ var len = observationStack.length;
+ var last = len > 0 && observationStack[len - 1];
+ return last && last.ignore === 0;
+ };
+ var noop = function () {
+ };
+ var observables;
+ var unbindComputes = function () {
+ for (var i = 0, len = observables.length; i < len; i++) {
+ canReflect.offValue(observables[i], noop);
+ }
+ observables = null;
+ };
+ Observation.temporarilyBind = function (compute) {
+ var computeInstance = compute.computeInstance || compute;
+ canReflect.onValue(computeInstance, noop);
+ if (!observables) {
+ observables = [];
+ setTimeout(unbindComputes, 10);
+ }
+ observables.push(computeInstance);
+ };
+ var callHandlers = function (newValue) {
+ this.handlers.forEach(function (handler) {
+ handler.call(this.compute, newValue);
+ }, this);
+ };
+ canReflect.set(Observation.prototype, canSymbol.for('can.onValue'), function (handler) {
+ if (!this.handlers) {
+ this.handlers = [];
+ this.compute.updater = callHandlers.bind(this);
+ }
+ if (!this.handlers.length) {
+ this.start();
+ }
+ this.handlers.push(handler);
+ });
+ canReflect.set(Observation.prototype, canSymbol.for('can.offValue'), function (handler) {
+ if (this.handlers) {
+ var index = this.handlers.indexOf(handler);
+ this.handlers.splice(index, 1);
+ if (this.handlers.length === 0) {
+ this.stop();
+ }
+ }
+ });
+ canReflect.set(Observation.prototype, canSymbol.for('can.getValue'), Observation.prototype.get);
+ Observation.prototype.hasDependencies = function () {
+ return this.bound ? !isEmptyObject(this.newObserved) : undefined;
+ };
+ canReflect.set(Observation.prototype, canSymbol.for('can.isValueLike'), true);
+ canReflect.set(Observation.prototype, canSymbol.for('can.isMapLike'), false);
+ canReflect.set(Observation.prototype, canSymbol.for('can.isListLike'), false);
+ canReflect.set(Observation.prototype, canSymbol.for('can.valueHasDependencies'), Observation.prototype.hasDependencies);
+ canReflect.set(Observation.prototype, canSymbol.for('can.getValueDependencies'), function () {
+ var rets;
+ if (this.bound === true) {
+ rets = {};
+ canReflect.eachKey(this.newObserved || {}, function (dep) {
+ if (canReflect.isValueLike(dep.obj)) {
+ rets.valueDependencies = rets.valueDependencies || new CIDSet();
+ rets.valueDependencies.add(dep.obj);
+ } else {
+ rets.keyDependencies = rets.keyDependencies || new CIDMap();
+ if (rets.keyDependencies.get(dep.obj)) {
+ rets.keyDependencies.get(dep.obj).push(dep.event);
+ } else {
+ rets.keyDependencies.set(dep.obj, [dep.event]);
+ }
+ }
+ });
+ }
+ return rets;
+ });
+ if (namespace.Observation) {
+ throw new Error('You can\'t have two versions of can-observation, check your dependencies');
+ } else {
+ module.exports = namespace.Observation = Observation;
+ }
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-event@3.7.6#lifecycle/lifecycle*/
+define('can-event/lifecycle/lifecycle', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-event'
+], function (require, exports, module) {
+ var canEvent = require('can-event');
+ var lifecycle = function (prototype) {
+ var baseAddEventListener = prototype.addEventListener;
+ var baseRemoveEventListener = prototype.removeEventListener;
+ prototype.addEventListener = function () {
+ var ret = baseAddEventListener.apply(this, arguments);
+ if (!this.__inSetup) {
+ this.__bindEvents = this.__bindEvents || {};
+ if (!this.__bindEvents._lifecycleBindings) {
+ this.__bindEvents._lifecycleBindings = 1;
+ if (this._eventSetup) {
+ this._eventSetup();
+ }
+ } else {
+ this.__bindEvents._lifecycleBindings++;
+ }
+ }
+ return ret;
+ };
+ prototype.removeEventListener = function (event, handler) {
+ if (!this.__bindEvents) {
+ return this;
+ }
+ var handlers = this.__bindEvents[event] || [];
+ var handlerCount = handlers.length;
+ var ret = baseRemoveEventListener.apply(this, arguments);
+ if (this.__bindEvents._lifecycleBindings === null) {
+ this.__bindEvents._lifecycleBindings = 0;
+ } else {
+ this.__bindEvents._lifecycleBindings -= handlerCount - handlers.length;
+ }
+ if (!this.__bindEvents._lifecycleBindings && this._eventTeardown) {
+ this._eventTeardown();
+ }
+ return ret;
+ };
+ return prototype;
+ };
+ var baseEvents = lifecycle({
+ addEventListener: canEvent.addEventListener,
+ removeEventListener: canEvent.removeEventListener
+ });
+ lifecycle.addAndSetup = baseEvents.addEventListener;
+ lifecycle.removeAndTeardown = baseEvents.removeEventListener;
+ module.exports = lifecycle;
+});
+/*can-util@3.10.18#js/is-promise-like/is-promise-like*/
+define('can-util/js/is-promise-like/is-promise-like', function (require, exports, module) {
+ 'use strict';
+ module.exports = function (obj) {
+ return !!obj && (typeof obj === 'object' || typeof obj === 'function') && typeof obj.then === 'function';
+ };
+});
+/*can-reflect-promise@1.1.5#can-reflect-promise*/
+define('can-reflect-promise', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-reflect',
+ 'can-symbol',
+ 'can-util/js/dev/dev',
+ 'can-observation',
+ 'can-cid',
+ 'can-util/js/assign/assign',
+ 'can-event',
+ 'can-util/js/single-reference/single-reference'
+], function (require, exports, module) {
+ var canReflect = require('can-reflect');
+ var canSymbol = require('can-symbol');
+ var dev = require('can-util/js/dev/dev');
+ var Observation = require('can-observation');
+ var CID = require('can-cid');
+ var assign = require('can-util/js/assign/assign');
+ var canEvent = require('can-event');
+ var singleReference = require('can-util/js/single-reference/single-reference');
+ var getValueSymbol = canSymbol.for('can.getValue'), getKeyValueSymbol = canSymbol.for('can.getKeyValue'), onValueSymbol = canSymbol.for('can.onValue'), onKeyValueSymbol = canSymbol.for('can.onKeyValue'), offKeyValueSymbol = canSymbol.for('can.offKeyValue'), observeDataSymbol = canSymbol.for('can.observeData');
+ var promiseDataPrototype = {
+ isPending: true,
+ state: 'pending',
+ isResolved: false,
+ isRejected: false,
+ value: undefined,
+ reason: undefined
+ };
+ assign(promiseDataPrototype, canEvent);
+ canReflect.set(promiseDataPrototype, onKeyValueSymbol, function (key, handler) {
+ var observeData = this;
+ var translated = function () {
+ handler(observeData[key]);
+ };
+ singleReference.set(handler, this, translated, key);
+ canEvent.on.call(this, 'state', translated);
+ });
+ canReflect.set(promiseDataPrototype, offKeyValueSymbol, function (key, handler) {
+ var translated = singleReference.getAndDelete(handler, this, key);
+ canEvent.off.call(this, 'state', translated);
+ });
+ function initPromise(promise) {
+ var observeData = promise[observeDataSymbol];
+ if (!observeData) {
+ Object.defineProperty(promise, observeDataSymbol, {
+ enumerable: false,
+ configurable: false,
+ writable: false,
+ value: Object.create(promiseDataPrototype)
+ });
+ observeData = promise[observeDataSymbol];
+ CID(observeData);
+ }
+ promise.then(function (value) {
+ observeData.isPending = false;
+ observeData.isResolved = true;
+ observeData.value = value;
+ observeData.state = 'resolved';
+ observeData.dispatch('state', [
+ 'resolved',
+ 'pending'
+ ]);
+ }, function (reason) {
+ observeData.isPending = false;
+ observeData.isRejected = true;
+ observeData.reason = reason;
+ observeData.state = 'rejected';
+ observeData.dispatch('state', [
+ 'rejected',
+ 'pending'
+ ]);
+ });
+ }
+ function setupPromise(value) {
+ var oldPromiseFn;
+ var proto = 'getPrototypeOf' in Object ? Object.getPrototypeOf(value) : value.__proto__;
+ if (value[getKeyValueSymbol] && value[observeDataSymbol]) {
+ return;
+ }
+ if (proto === null || proto === Object.prototype) {
+ proto = value;
+ if (typeof proto.promise === 'function') {
+ oldPromiseFn = proto.promise;
+ proto.promise = function () {
+ var result = oldPromiseFn.call(proto);
+ setupPromise(result);
+ return result;
+ };
+ }
+ }
+ [
+ getKeyValueSymbol,
+ function (key) {
+ if (!this[observeDataSymbol]) {
+ initPromise(this);
+ }
+ Observation.add(this[observeDataSymbol], 'state');
+ switch (key) {
+ case 'state':
+ case 'isPending':
+ case 'isResolved':
+ case 'isRejected':
+ case 'value':
+ case 'reason':
+ return this[observeDataSymbol][key];
+ default:
+ return this[key];
+ }
+ },
+ getValueSymbol,
+ function () {
+ return this[getKeyValueSymbol]('value');
+ },
+ canSymbol.for('can.isValueLike'),
+ false,
+ onValueSymbol,
+ function (handler) {
+ return this[onKeyValueSymbol]('value', handler);
+ },
+ onKeyValueSymbol,
+ function (key, handler) {
+ if (!this[observeDataSymbol]) {
+ initPromise(this);
+ }
+ var promise = this;
+ var translated = function () {
+ handler(promise[getKeyValueSymbol](key));
+ };
+ singleReference.set(handler, this, translated, key);
+ canEvent.on.call(this[observeDataSymbol], 'state', translated);
+ },
+ canSymbol.for('can.offValue'),
+ function (handler) {
+ return this[offKeyValueSymbol]('value', handler);
+ },
+ offKeyValueSymbol,
+ function (key, handler) {
+ var translated = singleReference.getAndDelete(handler, this, key);
+ if (translated) {
+ canEvent.off.call(this[observeDataSymbol], 'state', translated);
+ }
+ }
+ ].forEach(function (symbol, index, list) {
+ if (index % 2 === 0) {
+ canReflect.set(proto, symbol, list[index + 1]);
+ }
+ });
+ }
+ module.exports = setupPromise;
+});
+/*can-stache-key@0.1.3#can-stache-key*/
+define('can-stache-key', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-observation',
+ 'can-log/dev/dev',
+ 'can-util/js/each/each',
+ 'can-symbol',
+ 'can-reflect',
+ 'can-util/js/is-promise-like/is-promise-like',
+ 'can-reflect-promise'
+], function (require, exports, module) {
+ var Observation = require('can-observation');
+ var dev = require('can-log/dev/dev');
+ var each = require('can-util/js/each/each');
+ var canSymbol = require('can-symbol');
+ var canReflect = require('can-reflect');
+ var isPromiseLike = require('can-util/js/is-promise-like/is-promise-like');
+ var canReflectPromise = require('can-reflect-promise');
+ var getValueSymbol = canSymbol.for('can.getValue');
+ var setValueSymbol = canSymbol.for('can.setValue');
+ var isValueLikeSymbol = canSymbol.for('can.isValueLike');
+ var observeReader;
+ var isAt = function (index, reads) {
+ var prevRead = reads[index - 1];
+ return prevRead && prevRead.at;
+ };
+ var readValue = function (value, index, reads, options, state, prev) {
+ var usedValueReader;
+ do {
+ usedValueReader = false;
+ for (var i = 0, len = observeReader.valueReaders.length; i < len; i++) {
+ if (observeReader.valueReaders[i].test(value, index, reads, options)) {
+ value = observeReader.valueReaders[i].read(value, index, reads, options, state, prev);
+ }
+ }
+ } while (usedValueReader);
+ return value;
+ };
+ var specialRead = {
+ index: true,
+ key: true,
+ event: true,
+ element: true,
+ viewModel: true
+ };
+ var checkForObservableAndNotify = function (options, state, getObserves, value, index) {
+ if (options.foundObservable && !state.foundObservable) {
+ if (Observation.trapsCount()) {
+ Observation.addAll(getObserves());
+ options.foundObservable(value, index);
+ state.foundObservable = true;
+ }
+ }
+ };
+ observeReader = {
+ read: function (parent, reads, options) {
+ options = options || {};
+ var state = { foundObservable: false };
+ var getObserves;
+ if (options.foundObservable) {
+ getObserves = Observation.trap();
+ }
+ var cur = readValue(parent, 0, reads, options, state), type, prev, readLength = reads.length, i = 0, last;
+ checkForObservableAndNotify(options, state, getObserves, parent, 0);
+ while (i < readLength) {
+ prev = cur;
+ for (var r = 0, readersLength = observeReader.propertyReaders.length; r < readersLength; r++) {
+ var reader = observeReader.propertyReaders[r];
+ if (reader.test(cur)) {
+ cur = reader.read(cur, reads[i], i, options, state);
+ break;
+ }
+ }
+ checkForObservableAndNotify(options, state, getObserves, prev, i);
+ last = cur;
+ i = i + 1;
+ cur = readValue(cur, i, reads, options, state, prev);
+ checkForObservableAndNotify(options, state, getObserves, prev, i - 1);
+ type = typeof cur;
+ if (i < reads.length && (cur === null || cur === undefined)) {
+ if (options.earlyExit) {
+ options.earlyExit(prev, i - 1, cur);
+ }
+ return {
+ value: undefined,
+ parent: prev
+ };
+ }
+ }
+ if (cur === undefined) {
+ if (options.earlyExit) {
+ options.earlyExit(prev, i - 1);
+ }
+ }
+ return {
+ value: cur,
+ parent: prev
+ };
+ },
+ get: function (parent, reads, options) {
+ return observeReader.read(parent, observeReader.reads(reads), options || {}).value;
+ },
+ valueReadersMap: {},
+ valueReaders: [
+ {
+ name: 'function',
+ test: function (value) {
+ return value && canReflect.isFunctionLike(value) && !canReflect.isConstructorLike(value);
+ },
+ read: function (value, i, reads, options, state, prev) {
+ if (isAt(i, reads)) {
+ return i === reads.length ? value.bind(prev) : value;
+ }
+ if (options.callMethodsOnObservables && canReflect.isObservableLike(prev) && canReflect.isMapLike(prev)) {
+ return value.apply(prev, options.args || []);
+ } else if (options.isArgument && i === reads.length) {
+ if (options.proxyMethods === false) {
+ return value;
+ }
+ return value.bind(prev);
+ }
+ return value.apply(prev, options.args || []);
+ }
+ },
+ {
+ name: 'isValueLike',
+ test: function (value, i, reads, options) {
+ return value && value[getValueSymbol] && value[isValueLikeSymbol] !== false && (options.foundAt || !isAt(i, reads));
+ },
+ read: function (value, i, reads, options) {
+ if (options.readCompute === false && i === reads.length) {
+ return value;
+ }
+ return canReflect.getValue(value);
+ },
+ write: function (base, newVal) {
+ if (base[setValueSymbol]) {
+ base[setValueSymbol](newVal);
+ } else if (base.set) {
+ base.set(newVal);
+ } else {
+ base(newVal);
+ }
+ }
+ }
+ ],
+ propertyReadersMap: {},
+ propertyReaders: [
+ {
+ name: 'map',
+ test: function (value) {
+ if (isPromiseLike(value) || typeof value === 'object' && value && typeof value.then === 'function') {
+ canReflectPromise(value);
+ }
+ return canReflect.isObservableLike(value) && canReflect.isMapLike(value);
+ },
+ read: function (value, prop) {
+ var res = canReflect.getKeyValue(value, prop.key);
+ if (res !== undefined) {
+ return res;
+ } else {
+ return value[prop.key];
+ }
+ },
+ write: canReflect.setKeyValue
+ },
+ {
+ name: 'object',
+ test: function () {
+ return true;
+ },
+ read: function (value, prop, i, options) {
+ if (value == null) {
+ return undefined;
+ } else {
+ if (typeof value === 'object') {
+ if (prop.key in value) {
+ return value[prop.key];
+ } else if (prop.at && specialRead[prop.key] && '@' + prop.key in value) {
+ options.foundAt = true;
+ return value['@' + prop.key];
+ }
+ } else {
+ return value[prop.key];
+ }
+ }
+ },
+ write: function (base, prop, newVal) {
+ base[prop] = newVal;
+ }
+ }
+ ],
+ reads: function (keyArg) {
+ var key = '' + keyArg;
+ var keys = [];
+ var last = 0;
+ var at = false;
+ if (key.charAt(0) === '@') {
+ last = 1;
+ at = true;
+ }
+ var keyToAdd = '';
+ for (var i = last; i < key.length; i++) {
+ var character = key.charAt(i);
+ if (character === '.' || character === '@') {
+ if (key.charAt(i - 1) !== '\\') {
+ keys.push({
+ key: keyToAdd,
+ at: at
+ });
+ at = character === '@';
+ keyToAdd = '';
+ } else {
+ keyToAdd = keyToAdd.substr(0, keyToAdd.length - 1) + '.';
+ }
+ } else {
+ keyToAdd += character;
+ }
+ }
+ keys.push({
+ key: keyToAdd,
+ at: at
+ });
+ return keys;
+ },
+ write: function (parent, key, value, options) {
+ var keys = typeof key === 'string' ? observeReader.reads(key) : key;
+ var last;
+ options = options || {};
+ if (keys.length > 1) {
+ last = keys.pop();
+ parent = observeReader.read(parent, keys, options).value;
+ keys.push(last);
+ } else {
+ last = keys[0];
+ }
+ if (observeReader.valueReadersMap.isValueLike.test(parent[last.key], keys.length - 1, keys, options)) {
+ observeReader.valueReadersMap.isValueLike.write(parent[last.key], value, options);
+ } else {
+ if (observeReader.valueReadersMap.isValueLike.test(parent, keys.length - 1, keys, options)) {
+ parent = parent[getValueSymbol]();
+ }
+ if (observeReader.propertyReadersMap.map.test(parent)) {
+ observeReader.propertyReadersMap.map.write(parent, last.key, value, options);
+ } else if (observeReader.propertyReadersMap.object.test(parent)) {
+ observeReader.propertyReadersMap.object.write(parent, last.key, value, options);
+ if (options.observation) {
+ options.observation.update();
+ }
+ }
+ }
+ }
+ };
+ each(observeReader.propertyReaders, function (reader) {
+ observeReader.propertyReadersMap[reader.name] = reader;
+ });
+ each(observeReader.valueReaders, function (reader) {
+ observeReader.valueReadersMap[reader.name] = reader;
+ });
+ observeReader.set = observeReader.write;
+ module.exports = observeReader;
+});
+/*can-compute@3.3.10#proto-compute*/
+define('can-compute/proto-compute', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-observation',
+ 'can-event',
+ 'can-event/lifecycle/lifecycle',
+ 'can-event/batch/batch',
+ 'can-stache-key',
+ 'can-util/js/get/get',
+ 'can-cid',
+ 'can-util/js/assign/assign',
+ 'can-util/js/log/log',
+ 'can-reflect',
+ 'can-symbol',
+ 'can-util/js/cid-set/cid-set',
+ 'can-util/js/single-reference/single-reference'
+], function (require, exports, module) {
+ var Observation = require('can-observation');
+ var canEvent = require('can-event');
+ var eventLifecycle = require('can-event/lifecycle/lifecycle');
+ require('can-event/batch/batch');
+ var observeReader = require('can-stache-key');
+ var getObject = require('can-util/js/get/get');
+ var CID = require('can-cid');
+ var assign = require('can-util/js/assign/assign');
+ var canLog = require('can-util/js/log/log');
+ var canReflect = require('can-reflect');
+ var canSymbol = require('can-symbol');
+ var CIDSet = require('can-util/js/cid-set/cid-set');
+ var singleReference = require('can-util/js/single-reference/single-reference');
+ var Compute = function (getterSetter, context, eventName, bindOnce) {
+ CID(this, 'compute');
+ var args = [];
+ for (var i = 0, arglen = arguments.length; i < arglen; i++) {
+ args[i] = arguments[i];
+ }
+ var contextType = typeof args[1];
+ if (typeof args[0] === 'function') {
+ this._setupGetterSetterFn(args[0], args[1], args[2], args[3]);
+ } else if (args[1] !== undefined) {
+ if (contextType === 'string' || contextType === 'number') {
+ var isListLike = canReflect.isObservableLike(args[0]) && canReflect.isListLike(args[0]);
+ var isMapLike = canReflect.isObservableLike(args[0]) && canReflect.isMapLike(args[0]);
+ if (isMapLike || isListLike) {
+ var map = args[0];
+ var propertyName = args[1];
+ var mapGetterSetter = function (newValue) {
+ if (arguments.length) {
+ observeReader.set(map, propertyName, newValue);
+ } else {
+ if (isListLike) {
+ observeReader.get(map, 'length');
+ }
+ return observeReader.get(map, '' + propertyName);
+ }
+ };
+ this._setupGetterSetterFn(mapGetterSetter, args[1], args[2], args[3]);
+ } else {
+ this._setupProperty(args[0], args[1], args[2]);
+ }
+ } else if (contextType === 'function') {
+ this._setupSetter(args[0], args[1], args[2]);
+ } else {
+ if (args[1] && args[1].fn) {
+ this._setupAsyncCompute(args[0], args[1]);
+ } else {
+ this._setupSettings(args[0], args[1]);
+ }
+ }
+ } else {
+ this._setupSimpleValue(args[0]);
+ }
+ this._args = args;
+ this._primaryDepth = 0;
+ this.isComputed = true;
+ };
+ var updateOnChange = function (compute, newValue, oldValue, batchNum) {
+ var valueChanged = newValue !== oldValue && !(newValue !== newValue && oldValue !== oldValue);
+ if (valueChanged) {
+ canEvent.dispatch.call(compute, {
+ type: 'change',
+ batchNum: batchNum
+ }, [
+ newValue,
+ oldValue
+ ]);
+ }
+ };
+ var setupComputeHandlers = function (compute, func, context) {
+ var observation = new Observation(func, context, compute);
+ compute.observation = observation;
+ return {
+ _on: function () {
+ observation.start();
+ compute.value = observation.value;
+ },
+ _off: function () {
+ observation.stop();
+ },
+ getDepth: function () {
+ return observation.getDepth();
+ }
+ };
+ };
+ assign(Compute.prototype, {
+ setPrimaryDepth: function (depth) {
+ this._primaryDepth = depth;
+ },
+ _setupGetterSetterFn: function (getterSetter, context, eventName) {
+ this._set = context ? getterSetter.bind(context) : getterSetter;
+ this._get = context ? getterSetter.bind(context) : getterSetter;
+ this._canObserve = eventName === false ? false : true;
+ var handlers = setupComputeHandlers(this, getterSetter, context || this);
+ assign(this, handlers);
+ },
+ _setupProperty: function (target, propertyName, eventName) {
+ var self = this, handler;
+ handler = function () {
+ self.updater(self._get(), self.value);
+ };
+ this._get = function () {
+ return getObject(target, propertyName);
+ };
+ this._set = function (value) {
+ var properties = propertyName.split('.'), leafPropertyName = properties.pop();
+ if (properties.length) {
+ var targetProperty = getObject(target, properties.join('.'));
+ targetProperty[leafPropertyName] = value;
+ } else {
+ target[propertyName] = value;
+ }
+ };
+ this._on = function (update) {
+ canEvent.on.call(target, eventName || propertyName, handler);
+ this.value = this._get();
+ };
+ this._off = function () {
+ return canEvent.off.call(target, eventName || propertyName, handler);
+ };
+ },
+ _setupSetter: function (initialValue, setter, eventName) {
+ this.value = initialValue;
+ this._set = setter;
+ assign(this, eventName);
+ },
+ _setupSettings: function (initialValue, settings) {
+ this.value = initialValue;
+ this._set = settings.set || this._set;
+ this._get = settings.get || this._get;
+ if (!settings.__selfUpdater) {
+ var self = this, oldUpdater = this.updater;
+ this.updater = function () {
+ oldUpdater.call(self, self._get(), self.value);
+ };
+ }
+ this._on = settings.on ? settings.on : this._on;
+ this._off = settings.off ? settings.off : this._off;
+ },
+ _setupAsyncCompute: function (initialValue, settings) {
+ var self = this;
+ var getter = settings.fn;
+ var bindings;
+ this.value = initialValue;
+ this._setUpdates = true;
+ this.lastSetValue = new Compute(initialValue);
+ this._set = function (newVal) {
+ if (newVal === self.lastSetValue.get()) {
+ return this.value;
+ }
+ return self.lastSetValue.set(newVal);
+ };
+ this._get = function () {
+ return getter.call(settings.context, self.lastSetValue.get());
+ };
+ if (getter.length === 0) {
+ bindings = setupComputeHandlers(this, getter, settings.context);
+ } else if (getter.length === 1) {
+ bindings = setupComputeHandlers(this, function () {
+ return getter.call(settings.context, self.lastSetValue.get());
+ }, settings);
+ } else {
+ var oldUpdater = this.updater, resolve = Observation.ignore(function (newVal) {
+ oldUpdater.call(self, newVal, self.value);
+ });
+ this.updater = function (newVal) {
+ oldUpdater.call(self, newVal, self.value);
+ };
+ bindings = setupComputeHandlers(this, function () {
+ var res = getter.call(settings.context, self.lastSetValue.get(), resolve);
+ return res !== undefined ? res : this.value;
+ }, this);
+ }
+ assign(this, bindings);
+ },
+ _setupSimpleValue: function (initialValue) {
+ this.value = initialValue;
+ },
+ _eventSetup: Observation.ignore(function () {
+ this.bound = true;
+ this._on(this.updater);
+ }),
+ _eventTeardown: function () {
+ this._off(this.updater);
+ this.bound = false;
+ },
+ addEventListener: eventLifecycle.addAndSetup,
+ removeEventListener: eventLifecycle.removeAndTeardown,
+ clone: function (context) {
+ if (context && typeof this._args[0] === 'function') {
+ this._args[1] = context;
+ } else if (context) {
+ this._args[2] = context;
+ }
+ return new Compute(this._args[0], this._args[1], this._args[2], this._args[3]);
+ },
+ _on: function () {
+ },
+ _off: function () {
+ },
+ get: function () {
+ var recordingObservation = Observation.isRecording();
+ if (recordingObservation && this._canObserve !== false) {
+ Observation.add(this, 'change');
+ if (!this.bound) {
+ Compute.temporarilyBind(this);
+ }
+ }
+ if (this.bound) {
+ if (this.observation) {
+ return this.observation.get();
+ } else {
+ return this.value;
+ }
+ } else {
+ return this._get();
+ }
+ },
+ _get: function () {
+ return this.value;
+ },
+ set: function (newVal) {
+ var old = this.value;
+ var setVal = this._set(newVal, old);
+ if (this._setUpdates) {
+ return this.value;
+ }
+ if (this.hasDependencies) {
+ return this._get();
+ }
+ this.updater(setVal === undefined ? this._get() : setVal, old);
+ return this.value;
+ },
+ _set: function (newVal) {
+ return this.value = newVal;
+ },
+ updater: function (newVal, oldVal, batchNum) {
+ this.value = newVal;
+ if (this.observation) {
+ this.observation.value = newVal;
+ }
+ updateOnChange(this, newVal, oldVal, batchNum);
+ },
+ toFunction: function () {
+ return this._computeFn.bind(this);
+ },
+ _computeFn: function (newVal) {
+ if (arguments.length) {
+ return this.set(newVal);
+ }
+ return this.get();
+ }
+ });
+ var hasDependencies = function () {
+ return this.observation && this.observation.hasDependencies();
+ };
+ Object.defineProperty(Compute.prototype, 'hasDependencies', { get: hasDependencies });
+ canReflect.set(Compute.prototype, canSymbol.for('can.valueHasDependencies'), hasDependencies);
+ Compute.prototype.on = Compute.prototype.bind = Compute.prototype.addEventListener;
+ Compute.prototype.off = Compute.prototype.unbind = Compute.prototype.removeEventListener;
+ canReflect.set(Compute.prototype, canSymbol.for('can.onValue'), function (handler) {
+ var translationHandler = function (ev, newValue) {
+ handler(newValue);
+ };
+ singleReference.set(handler, this, translationHandler);
+ this.addEventListener('change', translationHandler);
+ });
+ canReflect.set(Compute.prototype, canSymbol.for('can.offValue'), function (handler) {
+ this.removeEventListener('change', singleReference.getAndDelete(handler, this));
+ });
+ canReflect.set(Compute.prototype, canSymbol.for('can.getValue'), Compute.prototype.get);
+ canReflect.set(Compute.prototype, canSymbol.for('can.setValue'), Compute.prototype.set);
+ Compute.temporarilyBind = Observation.temporarilyBind;
+ Compute.async = function (initialValue, asyncComputer, context) {
+ return new Compute(initialValue, {
+ fn: asyncComputer,
+ context: context
+ });
+ };
+ Compute.truthy = function (compute) {
+ return new Compute(function () {
+ var res = compute.get();
+ if (typeof res === 'function') {
+ res = res.get();
+ }
+ return !!res;
+ });
+ };
+ canReflect.set(Compute.prototype, canSymbol.for('can.setValue'), Compute.prototype.set);
+ canReflect.set(Compute.prototype, canSymbol.for('can.isValueLike'), true);
+ canReflect.set(Compute.prototype, canSymbol.for('can.isMapLike'), false);
+ canReflect.set(Compute.prototype, canSymbol.for('can.isListLike'), false);
+ canReflect.set(Compute.prototype, canSymbol.for('can.valueHasDependencies'), function () {
+ return !!this.observation;
+ });
+ canReflect.set(Compute.prototype, canSymbol.for('can.getValueDependencies'), function () {
+ var ret;
+ if (this.observation) {
+ ret = { valueDependencies: new CIDSet() };
+ ret.valueDependencies.add(this.observation);
+ }
+ return ret;
+ });
+ module.exports = exports = Compute;
+});
+/*can-compute@3.3.10#can-compute*/
+define('can-compute', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-event',
+ 'can-event/batch/batch',
+ 'can-compute/proto-compute',
+ 'can-cid',
+ 'can-namespace',
+ 'can-util/js/single-reference/single-reference',
+ 'can-reflect/reflections/get-set/get-set',
+ 'can-symbol'
+], function (require, exports, module) {
+ require('can-event');
+ require('can-event/batch/batch');
+ var Compute = require('can-compute/proto-compute');
+ var CID = require('can-cid');
+ var namespace = require('can-namespace');
+ var singleReference = require('can-util/js/single-reference/single-reference');
+ var canReflect = require('can-reflect/reflections/get-set/get-set');
+ var canSymbol = require('can-symbol');
+ var canOnValueSymbol = canSymbol.for('can.onValue'), canOffValueSymbol = canSymbol.for('can.offValue'), canGetValue = canSymbol.for('can.getValue'), canSetValue = canSymbol.for('can.setValue'), isValueLike = canSymbol.for('can.isValueLike'), isMapLike = canSymbol.for('can.isMapLike'), isListLike = canSymbol.for('can.isListLike'), isFunctionLike = canSymbol.for('can.isFunctionLike'), canValueHasDependencies = canSymbol.for('can.valueHasDependencies'), canGetValueDependencies = canSymbol.for('can.getValueDependencies');
+ var addEventListener = function (ev, handler) {
+ var compute = this;
+ var translationHandler;
+ if (handler) {
+ translationHandler = function () {
+ handler.apply(compute, arguments);
+ };
+ singleReference.set(handler, this, translationHandler);
+ }
+ return compute.computeInstance.addEventListener(ev, translationHandler);
+ };
+ var removeEventListener = function (ev, handler) {
+ var args = [];
+ if (typeof ev !== 'undefined') {
+ args.push(ev);
+ if (typeof handler !== 'undefined') {
+ args.push(singleReference.getAndDelete(handler, this));
+ }
+ }
+ return this.computeInstance.removeEventListener.apply(this.computeInstance, args);
+ };
+ var onValue = function (handler) {
+ return this.computeInstance[canOnValueSymbol](handler);
+ }, offValue = function (handler) {
+ return this.computeInstance[canOffValueSymbol](handler);
+ }, getValue = function () {
+ return this.computeInstance.get();
+ }, setValue = function (value) {
+ return this.computeInstance.set(value);
+ }, hasDependencies = function () {
+ return this.computeInstance.hasDependencies;
+ }, getDependencies = function () {
+ return this.computeInstance[canGetValueDependencies]();
+ };
+ var COMPUTE = function (getterSetter, context, eventName, bindOnce) {
+ function compute(val) {
+ if (arguments.length) {
+ return compute.computeInstance.set(val);
+ }
+ return compute.computeInstance.get();
+ }
+ var cid = CID(compute, 'compute');
+ compute.computeInstance = new Compute(getterSetter, context, eventName, bindOnce);
+ compute.handlerKey = '__handler' + cid;
+ compute.on = compute.bind = compute.addEventListener = addEventListener;
+ compute.off = compute.unbind = compute.removeEventListener = removeEventListener;
+ compute.isComputed = compute.computeInstance.isComputed;
+ compute.clone = function (ctx) {
+ if (typeof getterSetter === 'function') {
+ context = ctx;
+ }
+ return COMPUTE(getterSetter, context, ctx, bindOnce);
+ };
+ canReflect.set(compute, canOnValueSymbol, onValue);
+ canReflect.set(compute, canOffValueSymbol, offValue);
+ canReflect.set(compute, canGetValue, getValue);
+ canReflect.set(compute, canSetValue, setValue);
+ canReflect.set(compute, isValueLike, true);
+ canReflect.set(compute, isMapLike, false);
+ canReflect.set(compute, isListLike, false);
+ canReflect.set(compute, isFunctionLike, false);
+ canReflect.set(compute, canValueHasDependencies, hasDependencies);
+ canReflect.set(compute, canGetValueDependencies, getDependencies);
+ return compute;
+ };
+ COMPUTE.truthy = function (compute) {
+ return COMPUTE(function () {
+ var res = compute();
+ return !!res;
+ });
+ };
+ COMPUTE.async = function (initialValue, asyncComputer, context) {
+ return COMPUTE(initialValue, {
+ fn: asyncComputer,
+ context: context
+ });
+ };
+ COMPUTE.temporarilyBind = Compute.temporarilyBind;
+ module.exports = namespace.compute = COMPUTE;
+});
+/*can-stache-key@0.1.0#can-stache-key*/
+define('can-stache-key', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-observation',
+ 'can-util/js/dev/dev',
+ 'can-util/js/each/each',
+ 'can-symbol',
+ 'can-reflect',
+ 'can-util/js/is-promise-like/is-promise-like',
+ 'can-reflect-promise'
+], function (require, exports, module) {
+ var Observation = require('can-observation');
+ var dev = require('can-util/js/dev/dev');
+ var each = require('can-util/js/each/each');
+ var canSymbol = require('can-symbol');
+ var canReflect = require('can-reflect');
+ var isPromiseLike = require('can-util/js/is-promise-like/is-promise-like');
+ var canReflectPromise = require('can-reflect-promise');
+ var getValueSymbol = canSymbol.for('can.getValue');
+ var setValueSymbol = canSymbol.for('can.setValue');
+ var isValueLikeSymbol = canSymbol.for('can.isValueLike');
+ var observeReader;
+ var isAt = function (index, reads) {
+ var prevRead = reads[index - 1];
+ return prevRead && prevRead.at;
+ };
+ var readValue = function (value, index, reads, options, state, prev) {
+ var usedValueReader;
+ do {
+ usedValueReader = false;
+ for (var i = 0, len = observeReader.valueReaders.length; i < len; i++) {
+ if (observeReader.valueReaders[i].test(value, index, reads, options)) {
+ value = observeReader.valueReaders[i].read(value, index, reads, options, state, prev);
+ }
+ }
+ } while (usedValueReader);
+ return value;
+ };
+ var specialRead = {
+ index: true,
+ key: true,
+ event: true,
+ element: true,
+ viewModel: true
+ };
+ var checkForObservableAndNotify = function (options, state, getObserves, value, index) {
+ if (options.foundObservable && !state.foundObservable) {
+ if (Observation.trapsCount()) {
+ Observation.addAll(getObserves());
+ options.foundObservable(value, index);
+ state.foundObservable = true;
+ }
+ }
+ };
+ observeReader = {
+ read: function (parent, reads, options) {
+ options = options || {};
+ var state = { foundObservable: false };
+ var getObserves;
+ if (options.foundObservable) {
+ getObserves = Observation.trap();
+ }
+ var cur = readValue(parent, 0, reads, options, state), type, prev, readLength = reads.length, i = 0, last;
+ checkForObservableAndNotify(options, state, getObserves, parent, 0);
+ while (i < readLength) {
+ prev = cur;
+ for (var r = 0, readersLength = observeReader.propertyReaders.length; r < readersLength; r++) {
+ var reader = observeReader.propertyReaders[r];
+ if (reader.test(cur)) {
+ cur = reader.read(cur, reads[i], i, options, state);
+ break;
+ }
+ }
+ checkForObservableAndNotify(options, state, getObserves, prev, i);
+ last = cur;
+ i = i + 1;
+ cur = readValue(cur, i, reads, options, state, prev);
+ checkForObservableAndNotify(options, state, getObserves, prev, i - 1);
+ type = typeof cur;
+ if (i < reads.length && (cur === null || cur === undefined)) {
+ if (options.earlyExit) {
+ options.earlyExit(prev, i - 1, cur);
+ }
+ return {
+ value: undefined,
+ parent: prev
+ };
+ }
+ }
+ if (cur === undefined) {
+ if (options.earlyExit) {
+ options.earlyExit(prev, i - 1);
+ }
+ }
+ return {
+ value: cur,
+ parent: prev
+ };
+ },
+ get: function (parent, reads, options) {
+ return observeReader.read(parent, observeReader.reads(reads), options || {}).value;
+ },
+ valueReadersMap: {},
+ valueReaders: [
+ {
+ name: 'function',
+ test: function (value) {
+ return value && canReflect.isFunctionLike(value) && !canReflect.isConstructorLike(value);
+ },
+ read: function (value, i, reads, options, state, prev) {
+ if (isAt(i, reads)) {
+ return i === reads.length ? value.bind(prev) : value;
+ } else if (options.callMethodsOnObservables && canReflect.isObservableLike(prev) && canReflect.isMapLike(prev)) {
+ return value.apply(prev, options.args || []);
+ } else if (options.isArgument && i === reads.length) {
+ return options.proxyMethods !== false ? value.bind(prev) : value;
+ }
+ return value.apply(prev, options.args || []);
+ }
+ },
+ {
+ name: 'isValueLike',
+ test: function (value, i, reads, options) {
+ return value && value[getValueSymbol] && value[isValueLikeSymbol] !== false && (options.foundAt || !isAt(i, reads));
+ },
+ read: function (value, i, reads, options) {
+ if (options.readCompute === false && i === reads.length) {
+ return value;
+ }
+ return canReflect.getValue(value);
+ },
+ write: function (base, newVal) {
+ if (base[setValueSymbol]) {
+ base[setValueSymbol](newVal);
+ } else if (base.set) {
+ base.set(newVal);
+ } else {
+ base(newVal);
+ }
+ }
+ }
+ ],
+ propertyReadersMap: {},
+ propertyReaders: [
+ {
+ name: 'map',
+ test: function (value) {
+ if (isPromiseLike(value) || typeof value === 'object' && value && typeof value.then === 'function') {
+ canReflectPromise(value);
+ }
+ return canReflect.isObservableLike(value) && canReflect.isMapLike(value);
+ },
+ read: function (value, prop) {
+ var res = canReflect.getKeyValue(value, prop.key);
+ if (res !== undefined) {
+ return res;
+ } else {
+ return value[prop.key];
+ }
+ },
+ write: canReflect.setKeyValue
+ },
+ {
+ name: 'object',
+ test: function () {
+ return true;
+ },
+ read: function (value, prop, i, options) {
+ if (value == null) {
+ return undefined;
+ } else {
+ if (typeof value === 'object') {
+ if (prop.key in value) {
+ return value[prop.key];
+ } else if (prop.at && specialRead[prop.key] && '@' + prop.key in value) {
+ options.foundAt = true;
+ return value['@' + prop.key];
+ }
+ } else {
+ return value[prop.key];
+ }
+ }
+ },
+ write: function (base, prop, newVal) {
+ base[prop] = newVal;
+ }
+ }
+ ],
+ reads: function (keyArg) {
+ var key = '' + keyArg;
+ var keys = [];
+ var last = 0;
+ var at = false;
+ if (key.charAt(0) === '@') {
+ last = 1;
+ at = true;
+ }
+ var keyToAdd = '';
+ for (var i = last; i < key.length; i++) {
+ var character = key.charAt(i);
+ if (character === '.' || character === '@') {
+ if (key.charAt(i - 1) !== '\\') {
+ keys.push({
+ key: keyToAdd,
+ at: at
+ });
+ at = character === '@';
+ keyToAdd = '';
+ } else {
+ keyToAdd = keyToAdd.substr(0, keyToAdd.length - 1) + '.';
+ }
+ } else {
+ keyToAdd += character;
+ }
+ }
+ keys.push({
+ key: keyToAdd,
+ at: at
+ });
+ return keys;
+ },
+ write: function (parent, key, value, options) {
+ var keys = typeof key === 'string' ? observeReader.reads(key) : key;
+ var last;
+ options = options || {};
+ if (keys.length > 1) {
+ last = keys.pop();
+ parent = observeReader.read(parent, keys, options).value;
+ keys.push(last);
+ } else {
+ last = keys[0];
+ }
+ if (observeReader.valueReadersMap.isValueLike.test(parent[last.key], keys.length - 1, keys, options)) {
+ observeReader.valueReadersMap.isValueLike.write(parent[last.key], value, options);
+ } else {
+ if (observeReader.valueReadersMap.isValueLike.test(parent, keys.length - 1, keys, options)) {
+ parent = parent[getValueSymbol]();
+ }
+ if (observeReader.propertyReadersMap.map.test(parent)) {
+ observeReader.propertyReadersMap.map.write(parent, last.key, value, options);
+ } else if (observeReader.propertyReadersMap.object.test(parent)) {
+ observeReader.propertyReadersMap.object.write(parent, last.key, value, options);
+ if (options.observation) {
+ options.observation.update();
+ }
+ }
+ }
+ }
+ };
+ each(observeReader.propertyReaders, function (reader) {
+ observeReader.propertyReadersMap[reader.name] = reader;
+ });
+ each(observeReader.valueReaders, function (reader) {
+ observeReader.valueReadersMap[reader.name] = reader;
+ });
+ observeReader.set = observeReader.write;
+ module.exports = observeReader;
+});
+/*can-control@3.2.3#can-control*/
+define('can-control', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-construct',
+ 'can-namespace',
+ 'can-util/js/string/string',
+ 'can-util/js/assign/assign',
+ 'can-util/js/is-function/is-function',
+ 'can-util/js/each/each',
+ 'can-util/js/dev/dev',
+ 'can-types',
+ 'can-util/js/get/get',
+ 'can-util/dom/data/data',
+ 'can-util/dom/class-name/class-name',
+ 'can-util/dom/events/events',
+ 'can-event',
+ 'can-compute',
+ 'can-stache-key',
+ 'can-reflect',
+ 'can-util/dom/dispatch/dispatch',
+ 'can-util/dom/events/delegate/delegate'
+], function (require, exports, module) {
+ var Construct = require('can-construct');
+ var namespace = require('can-namespace');
+ var string = require('can-util/js/string/string');
+ var assign = require('can-util/js/assign/assign');
+ var isFunction = require('can-util/js/is-function/is-function');
+ var each = require('can-util/js/each/each');
+ var dev = require('can-util/js/dev/dev');
+ var types = require('can-types');
+ var get = require('can-util/js/get/get');
+ var domData = require('can-util/dom/data/data');
+ var className = require('can-util/dom/class-name/class-name');
+ var domEvents = require('can-util/dom/events/events');
+ var canEvent = require('can-event');
+ var canCompute = require('can-compute');
+ var observeReader = require('can-stache-key');
+ var canReflect = require('can-reflect');
+ var processors;
+ require('can-util/dom/dispatch/dispatch');
+ require('can-util/dom/events/delegate/delegate');
+ var bind = function (el, ev, callback) {
+ canEvent.on.call(el, ev, callback);
+ return function () {
+ canEvent.off.call(el, ev, callback);
+ };
+ }, slice = [].slice, paramReplacer = /\{([^\}]+)\}/g, delegate = function (el, selector, ev, callback) {
+ canEvent.on.call(el, ev, selector, callback);
+ return function () {
+ canEvent.off.call(el, ev, selector, callback);
+ };
+ }, binder = function (el, ev, callback, selector) {
+ return selector ? delegate(el, selector.trim(), ev, callback) : bind(el, ev, callback);
+ }, basicProcessor;
+ var Control = Construct.extend({
+ setup: function () {
+ Construct.setup.apply(this, arguments);
+ if (Control) {
+ var control = this, funcName;
+ control.actions = {};
+ for (funcName in control.prototype) {
+ if (control._isAction(funcName)) {
+ control.actions[funcName] = control._action(funcName);
+ }
+ }
+ }
+ },
+ _shifter: function (context, name) {
+ var method = typeof name === 'string' ? context[name] : name;
+ if (!isFunction(method)) {
+ method = context[method];
+ }
+ return function () {
+ var wrapped = types.wrapElement(this);
+ context.called = name;
+ return method.apply(context, [wrapped].concat(slice.call(arguments, 0)));
+ };
+ },
+ _isAction: function (methodName) {
+ var val = this.prototype[methodName], type = typeof val;
+ return methodName !== 'constructor' && (type === 'function' || type === 'string' && isFunction(this.prototype[val])) && !!(Control.isSpecial(methodName) || processors[methodName] || /[^\w]/.test(methodName));
+ },
+ _action: function (methodName, options, controlInstance) {
+ var readyCompute;
+ paramReplacer.lastIndex = 0;
+ if (options || !paramReplacer.test(methodName)) {
+ readyCompute = canCompute(function () {
+ var delegate;
+ var name = methodName.replace(paramReplacer, function (matched, key) {
+ var value, parent;
+ if (this._isDelegate(options, key)) {
+ delegate = this._getDelegate(options, key);
+ return '';
+ }
+ key = this._removeDelegateFromKey(key);
+ parent = this._lookup(options)[0];
+ value = observeReader.read(parent, observeReader.reads(key), { readCompute: false }).value;
+ if (value === undefined && typeof window !== 'undefined') {
+ value = get(window, key);
+ }
+ if (!parent || !(canReflect.isObservableLike(parent) && canReflect.isMapLike(parent)) && !value) {
+ return null;
+ }
+ if (typeof value === 'string') {
+ return value;
+ } else {
+ delegate = value;
+ return '';
+ }
+ }.bind(this));
+ name = name.trim();
+ var parts = name.split(/\s+/g), event = parts.pop();
+ return {
+ processor: this.processors[event] || basicProcessor,
+ parts: [
+ name,
+ parts.join(' '),
+ event
+ ],
+ delegate: delegate || undefined
+ };
+ }, this);
+ if (controlInstance) {
+ var handler = function (ev, ready) {
+ controlInstance._bindings.control[methodName](controlInstance.element);
+ controlInstance._bindings.control[methodName] = ready.processor(ready.delegate || controlInstance.element, ready.parts[2], ready.parts[1], methodName, controlInstance);
+ };
+ readyCompute.bind('change', handler);
+ controlInstance._bindings.readyComputes[methodName] = {
+ compute: readyCompute,
+ handler: handler
+ };
+ }
+ return readyCompute();
+ }
+ },
+ _lookup: function (options) {
+ return [
+ options,
+ window
+ ];
+ },
+ _removeDelegateFromKey: function (key) {
+ return key;
+ },
+ _isDelegate: function (options, key) {
+ return key === 'element';
+ },
+ _getDelegate: function (options, key) {
+ return undefined;
+ },
+ processors: {},
+ defaults: {},
+ convertElement: function (element) {
+ element = typeof element === 'string' ? document.querySelector(element) : element;
+ return types.wrapElement(element);
+ },
+ isSpecial: function (eventName) {
+ return eventName === 'inserted' || eventName === 'removed';
+ }
+ }, {
+ setup: function (element, options) {
+ var cls = this.constructor, pluginname = cls.pluginName || cls.shortName, arr;
+ if (!element) {
+ throw new Error('Creating an instance of a named control without passing an element');
+ }
+ this.element = cls.convertElement(element);
+ if (pluginname && pluginname !== 'can_control') {
+ className.add.call(this.element, pluginname);
+ }
+ arr = domData.get.call(this.element, 'controls');
+ if (!arr) {
+ arr = [];
+ domData.set.call(this.element, 'controls', arr);
+ }
+ arr.push(this);
+ if (canReflect.isObservableLike(options) && canReflect.isMapLike(options)) {
+ for (var prop in cls.defaults) {
+ if (!options.hasOwnProperty(prop)) {
+ observeReader.set(options, prop, cls.defaults[prop]);
+ }
+ }
+ this.options = options;
+ } else {
+ this.options = assign(assign({}, cls.defaults), options);
+ }
+ this.on();
+ return [
+ this.element,
+ this.options
+ ];
+ },
+ on: function (el, selector, eventName, func) {
+ if (!el) {
+ this.off();
+ var cls = this.constructor, bindings = this._bindings, actions = cls.actions, element = types.unwrapElement(this.element), destroyCB = Control._shifter(this, 'destroy'), funcName, ready;
+ for (funcName in actions) {
+ if (actions.hasOwnProperty(funcName)) {
+ ready = actions[funcName] || cls._action(funcName, this.options, this);
+ if (ready) {
+ bindings.control[funcName] = ready.processor(ready.delegate || element, ready.parts[2], ready.parts[1], funcName, this);
+ }
+ }
+ }
+ domEvents.addEventListener.call(element, 'removed', destroyCB);
+ bindings.user.push(function (el) {
+ domEvents.removeEventListener.call(el, 'removed', destroyCB);
+ });
+ return bindings.user.length;
+ }
+ if (typeof el === 'string') {
+ func = eventName;
+ eventName = selector;
+ selector = el;
+ el = this.element;
+ }
+ if (func === undefined) {
+ func = eventName;
+ eventName = selector;
+ selector = null;
+ }
+ if (typeof func === 'string') {
+ func = Control._shifter(this, func);
+ }
+ this._bindings.user.push(binder(el, eventName, func, selector));
+ return this._bindings.user.length;
+ },
+ off: function () {
+ var el = types.unwrapElement(this.element), bindings = this._bindings;
+ if (bindings) {
+ each(bindings.user || [], function (value) {
+ value(el);
+ });
+ each(bindings.control || {}, function (value) {
+ value(el);
+ });
+ each(bindings.readyComputes || {}, function (value) {
+ value.compute.unbind('change', value.handler);
+ });
+ }
+ this._bindings = {
+ user: [],
+ control: {},
+ readyComputes: {}
+ };
+ },
+ destroy: function () {
+ if (this.element === null) {
+ return;
+ }
+ var Class = this.constructor, pluginName = Class.pluginName || Class.shortName && string.underscore(Class.shortName), controls;
+ this.off();
+ if (pluginName && pluginName !== 'can_control') {
+ className.remove.call(this.element, pluginName);
+ }
+ controls = domData.get.call(this.element, 'controls');
+ if (controls) {
+ controls.splice(controls.indexOf(this), 1);
+ }
+ canEvent.dispatch.call(this, 'destroyed');
+ this.element = null;
+ }
+ });
+ processors = Control.processors;
+ basicProcessor = function (el, event, selector, methodName, control) {
+ return binder(el, event, Control._shifter(control, methodName), selector);
+ };
+ each([
+ 'beforeremove',
+ 'change',
+ 'click',
+ 'contextmenu',
+ 'dblclick',
+ 'keydown',
+ 'keyup',
+ 'keypress',
+ 'mousedown',
+ 'mousemove',
+ 'mouseout',
+ 'mouseover',
+ 'mouseup',
+ 'reset',
+ 'resize',
+ 'scroll',
+ 'select',
+ 'submit',
+ 'focusin',
+ 'focusout',
+ 'mouseenter',
+ 'mouseleave',
+ 'touchstart',
+ 'touchmove',
+ 'touchcancel',
+ 'touchend',
+ 'touchleave',
+ 'inserted',
+ 'removed',
+ 'dragstart',
+ 'dragenter',
+ 'dragover',
+ 'dragleave',
+ 'drag',
+ 'drop',
+ 'dragend'
+ ], function (v) {
+ processors[v] = basicProcessor;
+ });
+ module.exports = namespace.Control = Control;
+});
+/*can-component@3.3.6#control/control*/
+define('can-component/control/control', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-control',
+ 'can-util/js/each/each',
+ 'can-util/js/string/string',
+ 'can-compute',
+ 'can-stache-key'
+], function (require, exports, module) {
+ var Control = require('can-control');
+ var canEach = require('can-util/js/each/each');
+ var string = require('can-util/js/string/string');
+ var canCompute = require('can-compute');
+ var observeReader = require('can-stache-key');
+ var paramReplacer = /\{([^\}]+)\}/g;
+ var ComponentControl = Control.extend({
+ _lookup: function (options) {
+ return [
+ options.scope,
+ options,
+ window
+ ];
+ },
+ _removeDelegateFromKey: function (key) {
+ return key.replace(/^(scope|^viewModel)\./, '');
+ },
+ _isDelegate: function (options, key) {
+ return key === 'scope' || key === 'viewModel';
+ },
+ _getDelegate: function (options, key) {
+ return options[key];
+ },
+ _action: function (methodName, options, controlInstance) {
+ var hasObjectLookup;
+ paramReplacer.lastIndex = 0;
+ hasObjectLookup = paramReplacer.test(methodName);
+ if (!controlInstance && hasObjectLookup) {
+ return;
+ } else {
+ return Control._action.apply(this, arguments);
+ }
+ }
+ }, {
+ setup: function (el, options) {
+ this.scope = options.scope;
+ this.viewModel = options.viewModel;
+ return Control.prototype.setup.call(this, el, options);
+ },
+ off: function () {
+ if (this._bindings) {
+ canEach(this._bindings.readyComputes || {}, function (value) {
+ value.compute.unbind('change', value.handler);
+ });
+ }
+ Control.prototype.off.apply(this, arguments);
+ this._bindings.readyComputes = {};
+ },
+ destroy: function () {
+ Control.prototype.destroy.apply(this, arguments);
+ if (typeof this.options.destroy === 'function') {
+ this.options.destroy.apply(this, arguments);
+ }
+ }
+ });
+ module.exports = ComponentControl;
+});
+/*can-stache@3.14.3#expressions/arg*/
+define('can-stache/expressions/arg', function (require, exports, module) {
+ var Arg = function (expression, modifiers) {
+ this.expr = expression;
+ this.modifiers = modifiers || {};
+ this.isCompute = false;
+ };
+ Arg.prototype.value = function () {
+ return this.expr.value.apply(this.expr, arguments);
+ };
+ module.exports = Arg;
+});
+/*can-stache@3.14.3#expressions/literal*/
+define('can-stache/expressions/literal', function (require, exports, module) {
+ var Literal = function (value) {
+ this._value = value;
+ };
+ Literal.prototype.value = function () {
+ return this._value;
+ };
+ module.exports = Literal;
+});
+/*can-stache@3.14.3#src/expression-helpers*/
+define('can-stache/src/expression-helpers', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/expressions/arg',
+ 'can-stache/expressions/literal',
+ 'can-reflect',
+ 'can-compute',
+ 'can-stache-key',
+ 'can-symbol',
+ 'can-util/js/dev/dev'
+], function (require, exports, module) {
+ var Arg = require('can-stache/expressions/arg');
+ var Literal = require('can-stache/expressions/literal');
+ var canReflect = require('can-reflect');
+ var compute = require('can-compute');
+ var observeReader = require('can-stache-key');
+ var canSymbol = require('can-symbol');
+ var dev = require('can-util/js/dev/dev');
+ var getObservableValue_fromKey = function (key, scope, readOptions) {
+ var data = scope.computeData(key, readOptions);
+ compute.temporarilyBind(data);
+ return data;
+ };
+ function computeHasDependencies(compute) {
+ return compute[canSymbol.for('can.valueHasDependencies')] ? canReflect.valueHasDependencies(compute) : compute.computeInstance.hasDependencies;
+ }
+ function getObservableValue_fromDynamicKey_fromObservable(key, root, helperOptions, readOptions) {
+ var computeValue = compute(function (newVal) {
+ var keyValue = canReflect.getValue(key);
+ var rootValue = canReflect.getValue(root);
+ keyValue = ('' + keyValue).replace('.', '\\.');
+ if (arguments.length) {
+ observeReader.write(rootValue, observeReader.reads(keyValue), newVal);
+ } else {
+ return observeReader.get(rootValue, keyValue);
+ }
+ });
+ compute.temporarilyBind(computeValue);
+ return computeValue;
+ }
+ function convertToArgExpression(expr) {
+ if (!(expr instanceof Arg) && !(expr instanceof Literal)) {
+ return new Arg(expr);
+ } else {
+ return expr;
+ }
+ }
+ function toComputeOrValue(value) {
+ if (canReflect.isObservableLike(value)) {
+ if (canReflect.valueHasDependencies(value) === false) {
+ return canReflect.getValue(value);
+ }
+ if (value.compute) {
+ return value.compute;
+ }
+ }
+ return value;
+ }
+ function toCompute(value) {
+ if (value) {
+ if (value.isComputed) {
+ return value;
+ }
+ if (value.compute) {
+ return value.compute;
+ }
+ }
+ return value;
+ }
+ module.exports = {
+ getObservableValue_fromKey: getObservableValue_fromKey,
+ computeHasDependencies: computeHasDependencies,
+ getObservableValue_fromDynamicKey_fromObservable: getObservableValue_fromDynamicKey_fromObservable,
+ convertToArgExpression: convertToArgExpression,
+ toComputeOrValue: toComputeOrValue,
+ toCompute: toCompute
+ };
+});
+/*can-stache@3.14.3#expressions/hashes*/
+define('can-stache/expressions/hashes', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-reflect',
+ 'can-compute',
+ 'can-stache/src/expression-helpers'
+], function (require, exports, module) {
+ var canReflect = require('can-reflect');
+ var compute = require('can-compute');
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var Hashes = function (hashes) {
+ this.hashExprs = hashes;
+ };
+ Hashes.prototype.value = function (scope, helperOptions) {
+ var hash = {};
+ for (var prop in this.hashExprs) {
+ var val = expressionHelpers.convertToArgExpression(this.hashExprs[prop]), value = val.value.apply(val, arguments);
+ hash[prop] = {
+ call: !val.modifiers || !val.modifiers.compute,
+ value: value
+ };
+ }
+ return compute(function () {
+ var finalHash = {};
+ for (var prop in hash) {
+ finalHash[prop] = hash[prop].call ? canReflect.getValue(hash[prop].value) : expressionHelpers.toComputeOrValue(hash[prop].value);
+ }
+ return finalHash;
+ });
+ };
+ module.exports = Hashes;
+});
+/*can-stache@3.14.3#expressions/bracket*/
+define('can-stache/expressions/bracket', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/src/expression-helpers'
+], function (require, exports, module) {
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var Bracket = function (key, root, originalKey) {
+ this.root = root;
+ this.key = key;
+ };
+ Bracket.prototype.value = function (scope, helpers) {
+ var root = this.root ? this.root.value(scope, helpers) : scope.peek('.');
+ return expressionHelpers.getObservableValue_fromDynamicKey_fromObservable(this.key.value(scope, helpers), root, scope, helpers, {});
+ };
+ Bracket.prototype.closingTag = function () {
+ };
+ module.exports = Bracket;
+});
+/*can-simple-map@3.3.2#can-simple-map*/
+define('can-simple-map', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-construct',
+ 'can-event',
+ 'can-event/batch/batch',
+ 'can-util/js/assign/assign',
+ 'can-util/js/each/each',
+ 'can-types',
+ 'can-observation',
+ 'can-reflect',
+ 'can-util/js/single-reference/single-reference',
+ 'can-util/js/cid-map/cid-map'
+], function (require, exports, module) {
+ var Construct = require('can-construct');
+ var canEvent = require('can-event');
+ var canBatch = require('can-event/batch/batch');
+ var assign = require('can-util/js/assign/assign');
+ var each = require('can-util/js/each/each');
+ var types = require('can-types');
+ var Observation = require('can-observation');
+ var canReflect = require('can-reflect');
+ var singleReference = require('can-util/js/single-reference/single-reference');
+ var CIDMap = require('can-util/js/cid-map/cid-map');
+ var SimpleMap = Construct.extend({
+ setup: function (initialData) {
+ this._data = {};
+ this.attr(initialData);
+ },
+ attr: function (prop, value) {
+ var self = this;
+ if (arguments.length === 0) {
+ Observation.add(this, '__keys');
+ var data = {};
+ each(this._data, function (value, prop) {
+ Observation.add(this, prop);
+ data[prop] = value;
+ }, this);
+ return data;
+ } else if (arguments.length > 1) {
+ var had = this._data.hasOwnProperty(prop);
+ var old = this._data[prop];
+ this._data[prop] = value;
+ canBatch.start();
+ if (!had) {
+ canEvent.dispatch.call(this, '__keys', []);
+ }
+ canEvent.dispatch.call(this, prop, [
+ value,
+ old
+ ]);
+ canBatch.stop();
+ } else if (typeof prop === 'object') {
+ canReflect.eachKey(prop, function (value, key) {
+ self.attr(key, value);
+ });
+ } else {
+ if (prop !== 'constructor') {
+ Observation.add(this, prop);
+ return this._data[prop];
+ }
+ return this.constructor;
+ }
+ },
+ serialize: function () {
+ return canReflect.serialize(this, CIDMap);
+ },
+ get: function () {
+ return this.attr.apply(this, arguments);
+ },
+ set: function () {
+ return this.attr.apply(this, arguments);
+ }
+ });
+ assign(SimpleMap.prototype, canEvent);
+ if (!types.DefaultMap) {
+ types.DefaultMap = SimpleMap;
+ }
+ canReflect.assignSymbols(SimpleMap.prototype, {
+ 'can.isMapLike': true,
+ 'can.isListLike': false,
+ 'can.isValueLike': false,
+ 'can.getKeyValue': SimpleMap.prototype.get,
+ 'can.setKeyValue': SimpleMap.prototype.set,
+ 'can.deleteKeyValue': function (prop) {
+ return this.attr(prop, undefined);
+ },
+ 'can.getOwnEnumerableKeys': function () {
+ Observation.add(this, '__keys');
+ return Object.keys(this._data);
+ },
+ 'can.assignDeep': function (source) {
+ canBatch.start();
+ canReflect.assignMap(this, source);
+ canBatch.stop();
+ },
+ 'can.updateDeep': function (source) {
+ canBatch.start();
+ canReflect.updateMap(this, source);
+ canBatch.stop();
+ },
+ 'can.onKeyValue': function (key, handler) {
+ var translationHandler = function (ev, newValue, oldValue) {
+ handler.call(this, newValue, oldValue);
+ };
+ singleReference.set(handler, this, translationHandler, key);
+ this.addEventListener(key, translationHandler);
+ },
+ 'can.offKeyValue': function (key, handler) {
+ this.removeEventListener(key, singleReference.getAndDelete(handler, this, key));
+ },
+ 'can.keyHasDependencies': function (key) {
+ return false;
+ },
+ 'can.getKeyDependencies': function (key) {
+ return undefined;
+ }
+ });
+ module.exports = SimpleMap;
+});
+/*can-view-scope@3.5.5#template-context*/
+define('can-view-scope/template-context', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-simple-map'
+], function (require, exports, module) {
+ var SimpleMap = require('can-simple-map');
+ var TemplateContext = function () {
+ this.vars = new SimpleMap({});
+ };
+ module.exports = TemplateContext;
+});
+/*can-view-scope@3.5.5#compute_data*/
+define('can-view-scope/compute_data', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-observation',
+ 'can-stache-key',
+ 'can-compute',
+ 'can-util/js/assign/assign',
+ 'can-util/js/is-function/is-function',
+ 'can-event/batch/batch',
+ 'can-cid',
+ 'can-reflect',
+ 'can-symbol'
+], function (require, exports, module) {
+ 'use strict';
+ var Observation = require('can-observation');
+ var observeReader = require('can-stache-key');
+ var makeCompute = require('can-compute');
+ var assign = require('can-util/js/assign/assign');
+ var isFunction = require('can-util/js/is-function/is-function');
+ var canBatch = require('can-event/batch/batch');
+ var CID = require('can-cid');
+ var canReflect = require('can-reflect');
+ var canSymbol = require('can-symbol');
+ var getFastPathRoot = function (computeData) {
+ if (computeData.reads && computeData.reads.length === 1) {
+ var root = computeData.root;
+ if (root && root[canSymbol.for('can.getValue')]) {
+ root = canReflect.getValue(root);
+ }
+ return root && canReflect.isObservableLike(root) && canReflect.isMapLike(root) && !isFunction(root[computeData.reads[0].key]) && root;
+ }
+ return;
+ };
+ var isEventObject = function (obj) {
+ return obj && typeof obj.batchNum === 'number' && typeof obj.type === 'string';
+ };
+ var ScopeKeyData = function (scope, key, options) {
+ CID(this);
+ this.startingScope = scope;
+ this.key = key;
+ this.observation = new Observation(this.read, this);
+ this.options = assign({ observation: this.observation }, options);
+ this.handlers = [];
+ this.dispatchHandler = this.dispatch.bind(this);
+ this.fastPath = undefined;
+ this.root = undefined;
+ this.initialValue = undefined;
+ this.reads = undefined;
+ this.setRoot = undefined;
+ };
+ ScopeKeyData.prototype.getValue = function () {
+ Observation.add(this);
+ return this.getObservationValue();
+ };
+ ScopeKeyData.prototype.getObservationValue = Observation.ignore(function () {
+ return this.observation.get();
+ });
+ ScopeKeyData.prototype.read = function () {
+ if (this.root) {
+ return observeReader.read(this.root, this.reads, this.options).value;
+ }
+ var data = this.startingScope.read(this.key, this.options);
+ this.scope = data.scope;
+ this.reads = data.reads;
+ this.root = data.rootObserve;
+ this.setRoot = data.setRoot;
+ return this.initialValue = data.value;
+ };
+ ScopeKeyData.prototype.setValue = function (newVal) {
+ var root = this.root || this.setRoot;
+ if (root) {
+ observeReader.write(root, this.reads, newVal, this.options);
+ } else {
+ this.startingScope.set(this.key, newVal, this.options);
+ }
+ };
+ ScopeKeyData.prototype.hasDependencies = function () {
+ return this.observation.hasDependencies();
+ };
+ var canOnValue = canSymbol.for('can.onValue'), canOffValue = canSymbol.for('can.offValue');
+ canReflect.set(ScopeKeyData.prototype, canOnValue, function (handler) {
+ if (!this.handlers.length) {
+ canReflect.onValue(this.observation, this.dispatchHandler);
+ var fastPathRoot = getFastPathRoot(this);
+ if (fastPathRoot) {
+ var self = this, observation = this.observation;
+ this.fastPath = true;
+ observation.dependencyChange = function (target, newVal, altNewValue) {
+ if (isEventObject(newVal)) {
+ newVal = altNewValue;
+ }
+ if (target === fastPathRoot && typeof newVal !== 'function') {
+ this.newVal = newVal;
+ } else {
+ observation.dependencyChange = Observation.prototype.dependencyChange;
+ observation.start = Observation.prototype.start;
+ self.fastPath = false;
+ }
+ return Observation.prototype.dependencyChange.call(this, target, newVal, altNewValue);
+ };
+ observation.start = function () {
+ this.value = this.newVal;
+ };
+ }
+ }
+ this.handlers.push(handler);
+ });
+ ScopeKeyData.prototype.dispatch = function () {
+ var handlers = this.handlers.slice(0);
+ for (var i = 0, len = handlers.length; i < len; i++) {
+ canBatch.batchNum = this.observation.batchNum;
+ handlers[i].apply(this, arguments);
+ }
+ };
+ canReflect.set(ScopeKeyData.prototype, canOffValue, function (handler) {
+ var index = this.handlers.indexOf(handler);
+ this.handlers.splice(index, 1);
+ if (!this.handlers.length) {
+ canReflect.offValue(this.observation, this.dispatchHandler);
+ this.observation.dependencyChange = Observation.prototype.dependencyChange;
+ this.observation.start = Observation.prototype.start;
+ }
+ });
+ canReflect.set(ScopeKeyData.prototype, canSymbol.for('can.getValue'), ScopeKeyData.prototype.getValue);
+ canReflect.set(ScopeKeyData.prototype, canSymbol.for('can.setValue'), ScopeKeyData.prototype.setValue);
+ canReflect.set(ScopeKeyData.prototype, canSymbol.for('can.valueHasDependencies'), ScopeKeyData.prototype.hasDependencies);
+ Object.defineProperty(ScopeKeyData.prototype, 'compute', {
+ get: function () {
+ var scopeKeyData = this;
+ var compute = makeCompute(undefined, {
+ on: function (updater) {
+ scopeKeyData[canOnValue](updater);
+ this.value = scopeKeyData.observation.value;
+ },
+ off: function (updater) {
+ scopeKeyData[canOffValue](updater);
+ },
+ get: function () {
+ return scopeKeyData.observation.get();
+ },
+ set: function (newValue) {
+ return scopeKeyData.setValue(newValue);
+ }
+ });
+ compute.computeInstance.observation = this.observation;
+ compute.computeInstance._canObserve = false;
+ Object.defineProperty(this, 'compute', {
+ value: compute,
+ writable: false,
+ configurable: false
+ });
+ return compute;
+ },
+ configurable: true
+ });
+ module.exports = function (scope, key, options) {
+ return new ScopeKeyData(scope, key, options || { args: [] });
+ };
+});
+/*can-define-lazy-value@1.0.1#define-lazy-value*/
+define('can-define-lazy-value', function (require, exports, module) {
+ module.exports = function defineLazyValue(obj, prop, initializer, writable) {
+ Object.defineProperty(obj, prop, {
+ configurable: true,
+ get: function () {
+ Object.defineProperty(this, prop, {
+ value: undefined,
+ writable: true
+ });
+ var value = initializer.call(this, obj, prop);
+ Object.defineProperty(this, prop, {
+ value: value,
+ writable: !!writable
+ });
+ return value;
+ },
+ set: function (value) {
+ Object.defineProperty(this, prop, {
+ value: value,
+ writable: !!writable
+ });
+ return value;
+ }
+ });
+ };
+});
+/*can-view-scope@3.5.5#can-view-scope*/
+define('can-view-scope', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache-key',
+ 'can-observation',
+ 'can-view-scope/template-context',
+ 'can-view-scope/compute_data',
+ 'can-util/js/assign/assign',
+ 'can-util/js/each/each',
+ 'can-namespace',
+ 'can-reflect',
+ 'can-log/dev/dev',
+ 'can-define-lazy-value'
+], function (require, exports, module) {
+ var observeReader = require('can-stache-key');
+ var Observation = require('can-observation');
+ var TemplateContext = require('can-view-scope/template-context');
+ var makeComputeData = require('can-view-scope/compute_data');
+ var assign = require('can-util/js/assign/assign');
+ var each = require('can-util/js/each/each');
+ var namespace = require('can-namespace');
+ var canReflect = require('can-reflect');
+ var canLog = require('can-log/dev/dev');
+ var defineLazyValue = require('can-define-lazy-value');
+ var specialKeywords = {
+ index: true,
+ key: true,
+ element: true,
+ event: true,
+ viewModel: true,
+ arguments: true
+ };
+ function Scope(context, parent, meta) {
+ this._context = context;
+ this._parent = parent;
+ this._meta = meta || {};
+ this.__cache = {};
+ }
+ assign(Scope, {
+ read: observeReader.read,
+ Refs: TemplateContext,
+ refsScope: function () {
+ return new Scope(new TemplateContext());
+ },
+ keyInfo: function (attr) {
+ var info = {};
+ info.isDotSlash = attr.substr(0, 2) === './';
+ info.isThisDot = attr.substr(0, 5) === 'this.';
+ info.isThisAt = attr.substr(0, 5) === 'this@';
+ info.isInCurrentContext = info.isDotSlash || info.isThisDot || info.isThisAt;
+ info.isInParentContext = attr.substr(0, 3) === '../';
+ info.isCurrentContext = attr === '.' || attr === 'this';
+ info.isParentContext = attr === '..';
+ info.isScope = attr === 'scope';
+ info.isLegacyView = attr === '*self';
+ info.isInLegacyRefsScope = info.isLegacyView || attr.substr(0, 1) === '*' || attr.substr(0, 2) === '@*';
+ info.isInTemplateContextVars = info.isInLegacyRefsScope || attr.substr(0, 11) === 'scope.vars.';
+ info.isInTemplateContext = info.isInTemplateContextVars || attr.substr(0, 6) === 'scope.';
+ info.isContextBased = info.isInCurrentContext || info.isInParentContext || info.isCurrentContext || info.isParentContext;
+ return info;
+ }
+ });
+ assign(Scope.prototype, {
+ add: function (context, meta) {
+ if (context !== this._context) {
+ return new this.constructor(context, this, meta);
+ } else {
+ return this;
+ }
+ },
+ read: function (attr, options) {
+ if (attr === '%root') {
+ return { value: this.getRoot() };
+ }
+ if (attr === '%scope') {
+ return { value: this };
+ }
+ if (attr === './') {
+ attr = '.';
+ }
+ var keyInfo = Scope.keyInfo(attr);
+ if (keyInfo.isContextBased && (this._meta.notContext || this._meta.special)) {
+ return this._parent.read(attr, options);
+ }
+ var currentScopeOnly;
+ if (keyInfo.isInCurrentContext) {
+ currentScopeOnly = true;
+ attr = keyInfo.isDotSlash ? attr.substr(2) : attr.substr(5);
+ } else if (keyInfo.isInParentContext || keyInfo.isParentContext) {
+ var parent = this._parent;
+ while (parent._meta.notContext || parent._meta.special) {
+ parent = parent._parent;
+ }
+ if (keyInfo.isParentContext) {
+ return observeReader.read(parent._context, [], options);
+ }
+ return parent.read(attr.substr(3) || '.', options);
+ } else if (keyInfo.isCurrentContext) {
+ return observeReader.read(this._context, [], options);
+ } else if (keyInfo.isScope) {
+ return { value: this };
+ }
+ var keyReads = observeReader.reads(attr);
+ if (keyInfo.isInTemplateContext) {
+ if (keyInfo.isInLegacyRefsScope) {
+ } else {
+ keyReads = keyReads.slice(1);
+ }
+ if (specialKeywords[keyReads[0].key]) {
+ return this._read(keyReads, { special: true });
+ }
+ if (keyReads.length === 1) {
+ return { value: this.templateContext[keyReads[0].key] };
+ }
+ return this.getTemplateContext()._read(keyReads);
+ }
+ return this._read(keyReads, options, currentScopeOnly);
+ },
+ _read: function (keyReads, options, currentScopeOnly) {
+ var currentScope = this, currentContext, undefinedObserves = [], currentObserve, currentReads, setObserveDepth = -1, currentSetReads, currentSetObserve, ignoreSpecialContexts, ignoreNonSpecialContexts, readOptions = assign({
+ foundObservable: function (observe, nameIndex) {
+ currentObserve = observe;
+ currentReads = keyReads.slice(nameIndex);
+ },
+ earlyExit: function (parentValue, nameIndex) {
+ if (nameIndex > setObserveDepth || nameIndex === setObserveDepth && (typeof parentValue === 'object' && keyReads[nameIndex].key in parentValue)) {
+ currentSetObserve = currentObserve;
+ currentSetReads = currentReads;
+ setObserveDepth = nameIndex;
+ }
+ }
+ }, options);
+ while (currentScope) {
+ currentContext = currentScope._context;
+ ignoreNonSpecialContexts = options && options.special && !currentScope._meta.special;
+ ignoreSpecialContexts = (!options || options.special !== true) && currentScope._meta.special;
+ if (currentContext !== null && (typeof currentContext === 'object' || typeof currentContext === 'function') && !ignoreNonSpecialContexts && !ignoreSpecialContexts) {
+ var getObserves = Observation.trap();
+ var data = observeReader.read(currentContext, keyReads, readOptions);
+ var observes = getObserves();
+ if (data.value !== undefined) {
+ Observation.addAll(observes);
+ return {
+ scope: currentScope,
+ rootObserve: currentObserve,
+ value: data.value,
+ reads: currentReads
+ };
+ } else {
+ undefinedObserves.push.apply(undefinedObserves, observes);
+ }
+ }
+ if (currentScopeOnly) {
+ currentScope = null;
+ } else {
+ currentScope = currentScope._parent;
+ }
+ }
+ Observation.addAll(undefinedObserves);
+ return {
+ setRoot: currentSetObserve,
+ reads: currentSetReads,
+ value: undefined
+ };
+ },
+ get: function (key, options) {
+ options = assign({ isArgument: true }, options);
+ var res = this.read(key, options);
+ return res.value;
+ },
+ peek: Observation.ignore(function (key, options) {
+ return this.get(key, options);
+ }),
+ peak: Observation.ignore(function (key, options) {
+ return this.peek(key, options);
+ }),
+ getScope: function (tester) {
+ var scope = this;
+ while (scope) {
+ if (tester(scope)) {
+ return scope;
+ }
+ scope = scope._parent;
+ }
+ },
+ getContext: function (tester) {
+ var res = this.getScope(tester);
+ return res && res._context;
+ },
+ getRefs: function () {
+ return this.getTemplateContext();
+ },
+ getTemplateContext: function () {
+ var lastScope;
+ var templateContext = this.getScope(function (scope) {
+ lastScope = scope;
+ return scope._context instanceof TemplateContext;
+ });
+ if (!templateContext) {
+ templateContext = new Scope(new TemplateContext());
+ lastScope._parent = templateContext;
+ }
+ return templateContext;
+ },
+ getRoot: function () {
+ var cur = this, child = this;
+ while (cur._parent) {
+ child = cur;
+ cur = cur._parent;
+ }
+ if (cur._context instanceof Scope.Refs) {
+ cur = child;
+ }
+ return cur._context;
+ },
+ set: function (key, value, options) {
+ options = options || {};
+ var keyInfo = Scope.keyInfo(key), parent;
+ if (keyInfo.isCurrentContext) {
+ return canReflect.setValue(this._context, value);
+ } else if (keyInfo.isInParentContext || keyInfo.isParentContext) {
+ parent = this._parent;
+ while (parent._meta.notContext) {
+ parent = parent._parent;
+ }
+ if (keyInfo.isParentContext) {
+ return canReflect.setValue(parent._context, value);
+ }
+ return parent.set(key.substr(3) || '.', value, options);
+ } else if (keyInfo.isInTemplateContext) {
+ if (keyInfo.isInLegacyRefsScope) {
+ return this.vars.set(key.substr(1), value);
+ }
+ if (keyInfo.isInTemplateContextVars) {
+ return this.vars.set(key.substr(11), value);
+ }
+ key = key.substr(6);
+ if (key.indexOf('.') < 0) {
+ return this.templateContext[key] = value;
+ }
+ return this.getTemplateContext().set(key, value);
+ }
+ var dotIndex = key.lastIndexOf('.'), slashIndex = key.lastIndexOf('/'), contextPath, propName;
+ if (slashIndex > dotIndex) {
+ contextPath = key.substring(0, slashIndex);
+ propName = key.substring(slashIndex + 1, key.length);
+ } else {
+ if (dotIndex !== -1) {
+ contextPath = key.substring(0, dotIndex);
+ propName = key.substring(dotIndex + 1, key.length);
+ } else {
+ contextPath = '.';
+ propName = key;
+ }
+ }
+ var context = this.read(contextPath, options).value;
+ if (context === undefined) {
+ return;
+ }
+ if (!canReflect.isObservableLike(context) && canReflect.isObservableLike(context[propName])) {
+ if (canReflect.isMapLike(context[propName])) {
+ canLog.warn('can-view-scope: Merging data into "' + propName + '" because its parent is non-observable');
+ canReflect.updateDeep(context[propName], value);
+ } else if (canReflect.isValueLike(context[propName])) {
+ canReflect.setValue(context[propName], value);
+ } else {
+ observeReader.write(context, propName, value, options);
+ }
+ } else {
+ observeReader.write(context, propName, value, options);
+ }
+ },
+ attr: Observation.ignore(function (key, value, options) {
+ canLog.warn('can-view-scope::attr is deprecated, please use peek, get or set');
+ options = assign({ isArgument: true }, options);
+ if (arguments.length === 2) {
+ return this.set(key, value, options);
+ } else {
+ return this.get(key, options);
+ }
+ }),
+ computeData: function (key, options) {
+ return makeComputeData(this, key, options);
+ },
+ compute: function (key, options) {
+ return this.computeData(key, options).compute;
+ },
+ cloneFromRef: function () {
+ var contexts = [];
+ var scope = this, context, parent;
+ while (scope) {
+ context = scope._context;
+ if (context instanceof Scope.Refs) {
+ parent = scope._parent;
+ break;
+ }
+ contexts.unshift(context);
+ scope = scope._parent;
+ }
+ if (parent) {
+ each(contexts, function (context) {
+ parent = parent.add(context);
+ });
+ return parent;
+ } else {
+ return this;
+ }
+ }
+ });
+ defineLazyValue(Scope.prototype, 'templateContext', function () {
+ return this.getTemplateContext()._context;
+ });
+ defineLazyValue(Scope.prototype, 'vars', function () {
+ return this.templateContext.vars;
+ });
+ function Options(data, parent, meta) {
+ if (!data.helpers && !data.partials && !data.tags) {
+ data = { helpers: data };
+ }
+ Scope.call(this, data, parent, meta);
+ }
+ Options.prototype = new Scope();
+ Options.prototype.constructor = Options;
+ Scope.Options = Options;
+ namespace.view = namespace.view || {};
+ module.exports = namespace.view.Scope = Scope;
+});
+/*can-stache@3.14.3#src/set-identifier*/
+define('can-stache/src/set-identifier', function (require, exports, module) {
+ module.exports = function SetIdentifier(value) {
+ this.value = value;
+ };
+});
+/*can-stache@3.14.3#expressions/call*/
+define('can-stache/expressions/call', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-scope',
+ 'can-stache/expressions/hashes',
+ 'can-stache/src/set-identifier',
+ 'can-compute',
+ 'can-reflect',
+ 'can-symbol',
+ 'can-util/js/assign/assign',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-stache/src/expression-helpers'
+], function (require, exports, module) {
+ var Scope = require('can-view-scope');
+ var Hashes = require('can-stache/expressions/hashes');
+ var SetIdentifier = require('can-stache/src/set-identifier');
+ var compute = require('can-compute');
+ var canReflect = require('can-reflect');
+ var canSymbol = require('can-symbol');
+ var assign = require('can-util/js/assign/assign');
+ var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var Call = function (methodExpression, argExpressions) {
+ this.methodExpr = methodExpression;
+ this.argExprs = argExpressions.map(expressionHelpers.convertToArgExpression);
+ };
+ Call.prototype.args = function (scope, helperOptions) {
+ var hashExprs = {};
+ var args = [];
+ for (var i = 0, len = this.argExprs.length; i < len; i++) {
+ var arg = this.argExprs[i];
+ if (arg.expr instanceof Hashes) {
+ assign(hashExprs, arg.expr.hashExprs);
+ }
+ var value = arg.value.apply(arg, arguments);
+ args.push({
+ call: !arg.modifiers || !arg.modifiers.compute,
+ value: value
+ });
+ }
+ return function (doNotWrapArguments) {
+ var finalArgs = [];
+ if (!isEmptyObject(hashExprs)) {
+ finalArgs.hashExprs = hashExprs;
+ }
+ for (var i = 0, len = args.length; i < len; i++) {
+ if (doNotWrapArguments) {
+ finalArgs[i] = args[i].value;
+ } else {
+ finalArgs[i] = args[i].call ? canReflect.getValue(args[i].value) : expressionHelpers.toCompute(args[i].value);
+ }
+ }
+ return finalArgs;
+ };
+ };
+ Call.prototype.value = function (scope, helperScope, helperOptions) {
+ var method = this.methodExpr.value(scope, helperScope);
+ var metadata = method.metadata || {};
+ assign(this, metadata);
+ var getArgs = this.args(scope, helperScope);
+ var computeValue = compute(function (newVal) {
+ var func = canReflect.getValue(method.fn || method);
+ if (typeof func === 'function') {
+ var args = getArgs(metadata.isLiveBound);
+ if (metadata.isHelper && helperOptions) {
+ helperOptions.helpers = helperOptions.helpers || new Scope.Options({});
+ if (args.hashExprs && helperOptions.exprData) {
+ helperOptions.exprData.hashExprs = args.hashExprs;
+ }
+ args.push(helperOptions);
+ }
+ if (arguments.length) {
+ args.unshift(new SetIdentifier(newVal));
+ }
+ return func.apply(null, args);
+ }
+ });
+ compute.temporarilyBind(computeValue);
+ return computeValue;
+ };
+ Call.prototype.closingTag = function () {
+ return this.methodExpr.key;
+ };
+ module.exports = Call;
+});
+/*can-attribute-encoder@0.3.2#can-attribute-encoder*/
+define('can-attribute-encoder', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace',
+ 'can-log/dev/dev'
+], function (require, exports, module) {
+ var namespace = require('can-namespace');
+ var dev = require('can-log/dev/dev');
+ function each(items, callback) {
+ for (var i = 0; i < items.length; i++) {
+ callback(items[i], i);
+ }
+ }
+ function makeMap(str) {
+ var obj = {}, items = str.split(',');
+ each(items, function (name) {
+ obj[name] = true;
+ });
+ return obj;
+ }
+ var caseMattersAttributes = makeMap('allowReorder,attributeName,attributeType,autoReverse,baseFrequency,baseProfile,calcMode,clipPathUnits,contentScriptType,contentStyleType,diffuseConstant,edgeMode,externalResourcesRequired,filterRes,filterUnits,glyphRef,gradientTransform,gradientUnits,kernelMatrix,kernelUnitLength,keyPoints,keySplines,keyTimes,lengthAdjust,limitingConeAngle,markerHeight,markerUnits,markerWidth,maskContentUnits,maskUnits,patternContentUnits,patternTransform,patternUnits,pointsAtX,pointsAtY,pointsAtZ,preserveAlpha,preserveAspectRatio,primitiveUnits,repeatCount,repeatDur,requiredExtensions,requiredFeatures,specularConstant,specularExponent,spreadMethod,startOffset,stdDeviation,stitchTiles,surfaceScale,systemLanguage,tableValues,textLength,viewBox,viewTarget,xChannelSelector,yChannelSelector');
+ function camelCaseToSpinalCase(match, lowerCaseChar, upperCaseChar) {
+ return lowerCaseChar + '-' + upperCaseChar.toLowerCase();
+ }
+ function startsWith(allOfIt, startsWith) {
+ return allOfIt.indexOf(startsWith) === 0;
+ }
+ function endsWith(allOfIt, endsWith) {
+ return allOfIt.length - allOfIt.indexOf(endsWith) === endsWith.length;
+ }
+ var regexes = {
+ leftParens: /\(/g,
+ rightParens: /\)/g,
+ leftBrace: /\{/g,
+ rightBrace: /\}/g,
+ camelCase: /([a-z])([A-Z])/g,
+ forwardSlash: /\//g,
+ space: /\s/g,
+ uppercase: /[A-Z]/g,
+ uppercaseDelimiterThenChar: /:u:([a-z])/g,
+ caret: /\^/g,
+ dollar: /\$/g,
+ at: /@/g
+ };
+ var delimiters = {
+ prependUppercase: ':u:',
+ replaceSpace: ':s:',
+ replaceForwardSlash: ':f:',
+ replaceLeftParens: ':lp:',
+ replaceRightParens: ':rp:',
+ replaceLeftBrace: ':lb:',
+ replaceRightBrace: ':rb:',
+ replaceCaret: ':c:',
+ replaceDollar: ':d:',
+ replaceAt: ':at:'
+ };
+ var encoder = {};
+ encoder.encode = function (name) {
+ var encoded = name;
+ if (!caseMattersAttributes[encoded] && encoded.match(regexes.camelCase)) {
+ if (startsWith(encoded, 'on:') || endsWith(encoded, ':to') || endsWith(encoded, ':from') || endsWith(encoded, ':bind')) {
+ encoded = encoded.replace(regexes.uppercase, function (char) {
+ return delimiters.prependUppercase + char.toLowerCase();
+ });
+ } else {
+ encoded = encoded.replace(regexes.camelCase, camelCaseToSpinalCase);
+ }
+ }
+ encoded = encoded.replace(regexes.space, delimiters.replaceSpace).replace(regexes.forwardSlash, delimiters.replaceForwardSlash).replace(regexes.leftParens, delimiters.replaceLeftParens).replace(regexes.rightParens, delimiters.replaceRightParens).replace(regexes.leftBrace, delimiters.replaceLeftBrace).replace(regexes.rightBrace, delimiters.replaceRightBrace).replace(regexes.caret, delimiters.replaceCaret).replace(regexes.dollar, delimiters.replaceDollar).replace(regexes.at, delimiters.replaceAt);
+ return encoded;
+ };
+ encoder.decode = function (name) {
+ var decoded = name;
+ decoded = decoded.replace(delimiters.replaceLeftParens, '(').replace(delimiters.replaceRightParens, ')').replace(delimiters.replaceLeftBrace, '{').replace(delimiters.replaceRightBrace, '}').replace(delimiters.replaceForwardSlash, '/').replace(delimiters.replaceSpace, ' ').replace(delimiters.replaceCaret, '^').replace(delimiters.replaceDollar, '$').replace(delimiters.replaceAt, '@');
+ if (!caseMattersAttributes[decoded] && decoded.match(regexes.uppercaseDelimiterThenChar)) {
+ if (startsWith(decoded, 'on:') || endsWith(decoded, ':to') || endsWith(decoded, ':from') || endsWith(decoded, ':bind')) {
+ decoded = decoded.replace(regexes.uppercaseDelimiterThenChar, function (match, char) {
+ return char.toUpperCase();
+ });
+ }
+ }
+ return decoded;
+ };
+ if (namespace.encoder) {
+ throw new Error('You can\'t have two versions of can-attribute-encoder, check your dependencies');
+ } else {
+ module.exports = namespace.encoder = encoder;
+ }
+});
+/*can-view-parser@3.8.0#can-view-parser*/
+define('can-view-parser', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace',
+ 'can-log/dev/dev',
+ 'can-attribute-encoder'
+], function (require, exports, module) {
+ var namespace = require('can-namespace'), dev = require('can-log/dev/dev'), encoder = require('can-attribute-encoder');
+ function each(items, callback) {
+ for (var i = 0; i < items.length; i++) {
+ callback(items[i], i);
+ }
+ }
+ function makeMap(str) {
+ var obj = {}, items = str.split(',');
+ each(items, function (name) {
+ obj[name] = true;
+ });
+ return obj;
+ }
+ function handleIntermediate(intermediate, handler) {
+ for (var i = 0, len = intermediate.length; i < len; i++) {
+ var item = intermediate[i];
+ handler[item.tokenType].apply(handler, item.args);
+ }
+ return intermediate;
+ }
+ var alphaNumeric = 'A-Za-z0-9', alphaNumericHU = '-:_' + alphaNumeric, defaultMagicStart = '{{', endTag = new RegExp('^<\\/([' + alphaNumericHU + ']+)[^>]*>'), defaultMagicMatch = new RegExp('\\{\\{(![\\s\\S]*?!|[\\s\\S]*?)\\}\\}\\}?', 'g'), space = /\s/, alphaRegex = new RegExp('[' + alphaNumeric + ']');
+ var empty = makeMap('area,base,basefont,br,col,frame,hr,img,input,isindex,link,meta,param,embed');
+ var caseMattersElements = makeMap('altGlyph,altGlyphDef,altGlyphItem,animateColor,animateMotion,animateTransform,clipPath,feBlend,feColorMatrix,feComponentTransfer,feComposite,feConvolveMatrix,feDiffuseLighting,feDisplacementMap,feDistantLight,feFlood,feFuncA,feFuncB,feFuncG,feFuncR,feGaussianBlur,feImage,feMerge,feMergeNode,feMorphology,feOffset,fePointLight,feSpecularLighting,feSpotLight,feTile,feTurbulence,foreignObject,glyphRef,linearGradient,radialGradient,textPath');
+ var closeSelf = makeMap('colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr');
+ var special = makeMap('script');
+ var tokenTypes = 'start,end,close,attrStart,attrEnd,attrValue,chars,comment,special,done'.split(',');
+ var startOppositesMap = {
+ '{': '}',
+ '(': ')'
+ };
+ var fn = function () {
+ };
+ var HTMLParser = function (html, handler, returnIntermediate) {
+ if (typeof html === 'object') {
+ return handleIntermediate(html, handler);
+ }
+ var intermediate = [];
+ handler = handler || {};
+ if (returnIntermediate) {
+ each(tokenTypes, function (name) {
+ var callback = handler[name] || fn;
+ handler[name] = function () {
+ if (callback.apply(this, arguments) !== false) {
+ var end = arguments.length;
+ if (arguments[end - 1] === undefined) {
+ end = arguments.length - 1;
+ }
+ intermediate.push({
+ tokenType: name,
+ args: [].slice.call(arguments, 0, end)
+ });
+ }
+ };
+ });
+ }
+ var magicMatch = handler.magicMatch || defaultMagicMatch, magicStart = handler.magicStart || defaultMagicStart;
+ if (handler.magicMatch) {
+ dev.warn('can-view-parser: magicMatch is deprecated.');
+ }
+ if (handler.magicStart) {
+ dev.warn('can-view-parser: magicStart is deprecated.');
+ }
+ function parseStartTag(tag, tagName, rest, unary) {
+ tagName = caseMattersElements[tagName] ? tagName : tagName.toLowerCase();
+ if (closeSelf[tagName] && stack.last() === tagName) {
+ parseEndTag('', tagName);
+ }
+ unary = empty[tagName] || !!unary;
+ handler.start(tagName, unary, lineNo);
+ if (!unary) {
+ stack.push(tagName);
+ }
+ HTMLParser.parseAttrs(rest, handler, lineNo);
+ handler.end(tagName, unary, lineNo);
+ }
+ function parseEndTag(tag, tagName) {
+ var pos;
+ if (!tagName) {
+ pos = 0;
+ } else {
+ tagName = caseMattersElements[tagName] ? tagName : tagName.toLowerCase();
+ for (pos = stack.length - 1; pos >= 0; pos--) {
+ if (stack[pos] === tagName) {
+ break;
+ }
+ }
+ }
+ if (pos >= 0) {
+ for (var i = stack.length - 1; i >= pos; i--) {
+ if (handler.close) {
+ handler.close(stack[i], lineNo);
+ }
+ }
+ stack.length = pos;
+ }
+ }
+ function parseMustache(mustache, inside) {
+ if (handler.special) {
+ handler.special(inside, lineNo);
+ }
+ }
+ var callChars = function () {
+ if (charsText) {
+ if (handler.chars) {
+ handler.chars(charsText, lineNo);
+ }
+ }
+ charsText = '';
+ };
+ var index, chars, match, lineNo, stack = [], last = html, charsText = '';
+ stack.last = function () {
+ return this[this.length - 1];
+ };
+ while (html) {
+ chars = true;
+ if (!stack.last() || !special[stack.last()]) {
+ if (html.indexOf('');
+ if (index >= 0) {
+ callChars();
+ if (handler.comment) {
+ handler.comment(html.substring(4, index), lineNo);
+ }
+ html = html.substring(index + 3);
+ chars = false;
+ }
+ } else if (html.indexOf(']*>'), function (all, text) {
+ text = text.replace(/|/g, '$1$2');
+ if (handler.chars) {
+ handler.chars(text, lineNo);
+ }
+ return '';
+ });
+ parseEndTag('', stack.last());
+ }
+ if (html === last) {
+ throw new Error('Parse Error: ' + html);
+ }
+ last = html;
+ }
+ callChars();
+ parseEndTag();
+ handler.done(lineNo);
+ return intermediate;
+ };
+ var callAttrStart = function (state, curIndex, handler, rest, lineNo) {
+ var attrName = rest.substring(typeof state.nameStart === 'number' ? state.nameStart : curIndex, curIndex), newAttrName = encoder.encode(attrName);
+ state.attrStart = newAttrName;
+ handler.attrStart(state.attrStart, lineNo);
+ state.inName = false;
+ };
+ var callAttrEnd = function (state, curIndex, handler, rest, lineNo) {
+ if (state.valueStart !== undefined && state.valueStart < curIndex) {
+ var val = rest.substring(state.valueStart, curIndex);
+ handler.attrValue(val, lineNo);
+ }
+ handler.attrEnd(state.attrStart, lineNo);
+ state.attrStart = undefined;
+ state.valueStart = undefined;
+ state.inValue = false;
+ state.inName = false;
+ state.lookingForEq = false;
+ state.inQuote = false;
+ state.lookingForName = true;
+ };
+ var findBreak = function (str, magicStart) {
+ var magicLength = magicStart.length;
+ for (var i = 0, len = str.length; i < len; i++) {
+ if (str[i] === '<' || str.substr(i, magicLength) === magicStart) {
+ return i;
+ }
+ }
+ return -1;
+ };
+ HTMLParser.parseAttrs = function (rest, handler, lineNo) {
+ if (!rest) {
+ return;
+ }
+ var magicMatch = handler.magicMatch || defaultMagicMatch, magicStart = handler.magicStart || defaultMagicStart;
+ var i = 0;
+ var curIndex;
+ var state = {
+ inName: false,
+ nameStart: undefined,
+ inValue: false,
+ valueStart: undefined,
+ inQuote: false,
+ attrStart: undefined,
+ lookingForName: true,
+ lookingForValue: false,
+ lookingForEq: false
+ };
+ while (i < rest.length) {
+ curIndex = i;
+ var cur = rest.charAt(i);
+ i++;
+ if (magicStart === rest.substr(curIndex, magicStart.length)) {
+ if (state.inValue && curIndex > state.valueStart) {
+ handler.attrValue(rest.substring(state.valueStart, curIndex), lineNo);
+ } else if (state.inName && state.nameStart < curIndex) {
+ callAttrStart(state, curIndex, handler, rest, lineNo);
+ callAttrEnd(state, curIndex, handler, rest, lineNo);
+ } else if (state.lookingForValue) {
+ state.inValue = true;
+ } else if (state.lookingForEq && state.attrStart) {
+ callAttrEnd(state, curIndex, handler, rest, lineNo);
+ }
+ magicMatch.lastIndex = curIndex;
+ var match = magicMatch.exec(rest);
+ if (match) {
+ handler.special(match[1], lineNo);
+ i = curIndex + match[0].length;
+ if (state.inValue) {
+ state.valueStart = curIndex + match[0].length;
+ }
+ }
+ } else if (state.inValue) {
+ if (state.inQuote) {
+ if (cur === state.inQuote) {
+ callAttrEnd(state, curIndex, handler, rest, lineNo);
+ }
+ } else if (space.test(cur)) {
+ callAttrEnd(state, curIndex, handler, rest, lineNo);
+ }
+ } else if (cur === '=' && (state.lookingForEq || state.lookingForName || state.inName)) {
+ if (!state.attrStart) {
+ callAttrStart(state, curIndex, handler, rest, lineNo);
+ }
+ state.lookingForValue = true;
+ state.lookingForEq = false;
+ state.lookingForName = false;
+ } else if (state.inName) {
+ var started = rest[state.nameStart], otherStart, otherOpposite;
+ if (startOppositesMap[started] === cur) {
+ otherStart = started === '{' ? '(' : '{';
+ otherOpposite = startOppositesMap[otherStart];
+ if (rest[curIndex + 1] === otherOpposite) {
+ callAttrStart(state, curIndex + 2, handler, rest, lineNo);
+ i++;
+ } else {
+ callAttrStart(state, curIndex + 1, handler, rest, lineNo);
+ }
+ state.lookingForEq = true;
+ } else if (space.test(cur) && started !== '{' && started !== '(') {
+ callAttrStart(state, curIndex, handler, rest, lineNo);
+ state.lookingForEq = true;
+ }
+ } else if (state.lookingForName) {
+ if (!space.test(cur)) {
+ if (state.attrStart) {
+ callAttrEnd(state, curIndex, handler, rest, lineNo);
+ }
+ state.nameStart = curIndex;
+ state.inName = true;
+ }
+ } else if (state.lookingForValue) {
+ if (!space.test(cur)) {
+ state.lookingForValue = false;
+ state.inValue = true;
+ if (cur === '\'' || cur === '"') {
+ state.inQuote = cur;
+ state.valueStart = curIndex + 1;
+ } else {
+ state.valueStart = curIndex;
+ }
+ } else if (i === rest.length) {
+ callAttrEnd(state, curIndex, handler, rest, lineNo);
+ }
+ }
+ }
+ if (state.inName) {
+ callAttrStart(state, curIndex + 1, handler, rest, lineNo);
+ callAttrEnd(state, curIndex + 1, handler, rest, lineNo);
+ } else if (state.lookingForEq || state.lookingForValue || state.inValue) {
+ callAttrEnd(state, curIndex + 1, handler, rest, lineNo);
+ }
+ magicMatch.lastIndex = 0;
+ };
+ HTMLParser.searchStartTag = function (html) {
+ var closingIndex = html.indexOf('>');
+ if (closingIndex === -1 || !alphaRegex.test(html[1])) {
+ return null;
+ }
+ var tagName, tagContent, match, rest = '', unary = '';
+ var startTag = html.substring(0, closingIndex + 1);
+ var isUnary = startTag[startTag.length - 2] === '/';
+ var spaceIndex = startTag.search(space);
+ if (isUnary) {
+ unary = '/';
+ tagContent = startTag.substring(1, startTag.length - 2).trim();
+ } else {
+ tagContent = startTag.substring(1, startTag.length - 1).trim();
+ }
+ if (spaceIndex === -1) {
+ tagName = tagContent;
+ } else {
+ spaceIndex--;
+ tagName = tagContent.substring(0, spaceIndex);
+ rest = tagContent.substring(spaceIndex);
+ }
+ match = [
+ startTag,
+ tagName,
+ rest,
+ unary
+ ];
+ return {
+ match: match,
+ html: html.substring(startTag.length)
+ };
+ };
+ module.exports = namespace.HTMLParser = HTMLParser;
+});
+/*can-util@3.10.18#js/set-immediate/set-immediate*/
+define('can-util/js/set-immediate/set-immediate', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/global/global'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var global = require('can-globals/global/global')();
+ module.exports = global.setImmediate || function (cb) {
+ return setTimeout(cb, 0);
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/child-nodes/child-nodes*/
+define('can-util/dom/child-nodes/child-nodes', function (require, exports, module) {
+ 'use strict';
+ function childNodes(node) {
+ var childNodes = node.childNodes;
+ if ('length' in childNodes) {
+ return childNodes;
+ } else {
+ var cur = node.firstChild;
+ var nodes = [];
+ while (cur) {
+ nodes.push(cur);
+ cur = cur.nextSibling;
+ }
+ return nodes;
+ }
+ }
+ module.exports = childNodes;
+});
+/*can-util@3.10.18#dom/contains/contains*/
+define('can-util/dom/contains/contains', function (require, exports, module) {
+ 'use strict';
+ module.exports = function (child) {
+ return this.contains(child);
+ };
+});
+/*can-util@3.10.18#dom/mutate/mutate*/
+define('can-util/dom/mutate/mutate', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/make-array/make-array',
+ 'can-util/js/set-immediate/set-immediate',
+ 'can-cid',
+ 'can-globals/mutation-observer/mutation-observer',
+ 'can-util/dom/child-nodes/child-nodes',
+ 'can-util/dom/contains/contains',
+ 'can-util/dom/dispatch/dispatch',
+ 'can-globals/document/document',
+ 'can-util/dom/data/data'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var makeArray = require('can-util/js/make-array/make-array');
+ var setImmediate = require('can-util/js/set-immediate/set-immediate');
+ var CID = require('can-cid');
+ var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
+ var childNodes = require('can-util/dom/child-nodes/child-nodes');
+ var domContains = require('can-util/dom/contains/contains');
+ var domDispatch = require('can-util/dom/dispatch/dispatch');
+ var getDocument = require('can-globals/document/document');
+ var domData = require('can-util/dom/data/data');
+ var mutatedElements;
+ var checks = {
+ inserted: function (root, elem) {
+ return domContains.call(root, elem);
+ },
+ removed: function (root, elem) {
+ return !domContains.call(root, elem);
+ }
+ };
+ var fireOn = function (elems, root, check, event, dispatched) {
+ if (!elems.length) {
+ return;
+ }
+ var children, cid;
+ for (var i = 0, elem; (elem = elems[i]) !== undefined; i++) {
+ cid = CID(elem);
+ if (elem.getElementsByTagName && check(root, elem) && !dispatched[cid]) {
+ dispatched[cid] = true;
+ children = makeArray(elem.getElementsByTagName('*'));
+ domDispatch.call(elem, event, [], false);
+ if (event === 'removed') {
+ domData.delete.call(elem);
+ }
+ for (var j = 0, child; (child = children[j]) !== undefined; j++) {
+ cid = CID(child);
+ if (!dispatched[cid]) {
+ domDispatch.call(child, event, [], false);
+ if (event === 'removed') {
+ domData.delete.call(child);
+ }
+ dispatched[cid] = true;
+ }
+ }
+ }
+ }
+ };
+ var fireMutations = function () {
+ var mutations = mutatedElements;
+ mutatedElements = null;
+ var firstElement = mutations[0][1][0];
+ var doc = getDocument() || firstElement.ownerDocument || firstElement;
+ var root = doc.contains ? doc : doc.documentElement;
+ var dispatched = {
+ inserted: {},
+ removed: {}
+ };
+ mutations.forEach(function (mutation) {
+ fireOn(mutation[1], root, checks[mutation[0]], mutation[0], dispatched[mutation[0]]);
+ });
+ };
+ var mutated = function (elements, type) {
+ if (!getMutationObserver() && elements.length) {
+ var firstElement = elements[0];
+ var doc = getDocument() || firstElement.ownerDocument || firstElement;
+ var root = doc.contains ? doc : doc.documentElement;
+ if (checks.inserted(root, firstElement)) {
+ if (!mutatedElements) {
+ mutatedElements = [];
+ setImmediate(fireMutations);
+ }
+ mutatedElements.push([
+ type,
+ elements
+ ]);
+ }
+ }
+ };
+ module.exports = {
+ appendChild: function (child) {
+ if (getMutationObserver()) {
+ this.appendChild(child);
+ } else {
+ var children;
+ if (child.nodeType === 11) {
+ children = makeArray(childNodes(child));
+ } else {
+ children = [child];
+ }
+ this.appendChild(child);
+ mutated(children, 'inserted');
+ }
+ },
+ insertBefore: function (child, ref, document) {
+ if (getMutationObserver()) {
+ this.insertBefore(child, ref);
+ } else {
+ var children;
+ if (child.nodeType === 11) {
+ children = makeArray(childNodes(child));
+ } else {
+ children = [child];
+ }
+ this.insertBefore(child, ref);
+ mutated(children, 'inserted');
+ }
+ },
+ removeChild: function (child) {
+ if (getMutationObserver()) {
+ this.removeChild(child);
+ } else {
+ mutated([child], 'removed');
+ this.removeChild(child);
+ }
+ },
+ replaceChild: function (newChild, oldChild) {
+ if (getMutationObserver()) {
+ this.replaceChild(newChild, oldChild);
+ } else {
+ var children;
+ if (newChild.nodeType === 11) {
+ children = makeArray(childNodes(newChild));
+ } else {
+ children = [newChild];
+ }
+ mutated([oldChild], 'removed');
+ this.replaceChild(newChild, oldChild);
+ mutated(children, 'inserted');
+ }
+ },
+ inserted: function (elements) {
+ mutated(elements, 'inserted');
+ },
+ removed: function (elements) {
+ mutated(elements, 'removed');
+ }
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-view-nodelist@3.1.1#can-view-nodelist*/
+define('can-view-nodelist', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/make-array/make-array',
+ 'can-util/js/each/each',
+ 'can-namespace',
+ 'can-util/dom/mutate/mutate',
+ 'can-util/js/cid-map/cid-map'
+], function (require, exports, module) {
+ var makeArray = require('can-util/js/make-array/make-array');
+ var each = require('can-util/js/each/each');
+ var namespace = require('can-namespace');
+ var domMutate = require('can-util/dom/mutate/mutate');
+ var CIDMap = require('can-util/js/cid-map/cid-map');
+ var nodeMap = new CIDMap(), splice = [].splice, push = [].push, itemsInChildListTree = function (list) {
+ var count = 0;
+ for (var i = 0, len = list.length; i < len; i++) {
+ var item = list[i];
+ if (item.nodeType) {
+ count++;
+ } else {
+ count += itemsInChildListTree(item);
+ }
+ }
+ return count;
+ }, replacementMap = function (replacements) {
+ var map = new CIDMap();
+ for (var i = 0, len = replacements.length; i < len; i++) {
+ var node = nodeLists.first(replacements[i]);
+ map.set(node, replacements[i]);
+ }
+ return map;
+ }, addUnfoundAsDeepChildren = function (list, rMap) {
+ rMap.forEach(function (replacement) {
+ list.newDeepChildren.push(replacement);
+ });
+ };
+ var nodeLists = {
+ update: function (nodeList, newNodes) {
+ var oldNodes = nodeLists.unregisterChildren(nodeList);
+ newNodes = makeArray(newNodes);
+ var oldListLength = nodeList.length;
+ splice.apply(nodeList, [
+ 0,
+ oldListLength
+ ].concat(newNodes));
+ if (nodeList.replacements) {
+ nodeLists.nestReplacements(nodeList);
+ nodeList.deepChildren = nodeList.newDeepChildren;
+ nodeList.newDeepChildren = [];
+ } else {
+ nodeLists.nestList(nodeList);
+ }
+ return oldNodes;
+ },
+ nestReplacements: function (list) {
+ var index = 0, rMap = replacementMap(list.replacements), rCount = list.replacements.length;
+ while (index < list.length && rCount) {
+ var node = list[index], replacement = rMap.get(node);
+ if (replacement) {
+ rMap['delete'](node);
+ list.splice(index, itemsInChildListTree(replacement), replacement);
+ rCount--;
+ }
+ index++;
+ }
+ if (rCount) {
+ addUnfoundAsDeepChildren(list, rMap);
+ }
+ list.replacements = [];
+ },
+ nestList: function (list) {
+ var index = 0;
+ while (index < list.length) {
+ var node = list[index], childNodeList = nodeMap.get(node);
+ if (childNodeList) {
+ if (childNodeList !== list) {
+ list.splice(index, itemsInChildListTree(childNodeList), childNodeList);
+ }
+ } else {
+ nodeMap.set(node, list);
+ }
+ index++;
+ }
+ },
+ last: function (nodeList) {
+ var last = nodeList[nodeList.length - 1];
+ if (last.nodeType) {
+ return last;
+ } else {
+ return nodeLists.last(last);
+ }
+ },
+ first: function (nodeList) {
+ var first = nodeList[0];
+ if (first.nodeType) {
+ return first;
+ } else {
+ return nodeLists.first(first);
+ }
+ },
+ flatten: function (nodeList) {
+ var items = [];
+ for (var i = 0; i < nodeList.length; i++) {
+ var item = nodeList[i];
+ if (item.nodeType) {
+ items.push(item);
+ } else {
+ items.push.apply(items, nodeLists.flatten(item));
+ }
+ }
+ return items;
+ },
+ register: function (nodeList, unregistered, parent, directlyNested) {
+ nodeList.unregistered = unregistered;
+ nodeList.parentList = parent;
+ nodeList.nesting = parent && typeof parent.nesting !== 'undefined' ? parent.nesting + 1 : 0;
+ if (parent) {
+ nodeList.deepChildren = [];
+ nodeList.newDeepChildren = [];
+ nodeList.replacements = [];
+ if (parent !== true) {
+ if (directlyNested) {
+ parent.replacements.push(nodeList);
+ } else {
+ parent.newDeepChildren.push(nodeList);
+ }
+ }
+ } else {
+ nodeLists.nestList(nodeList);
+ }
+ return nodeList;
+ },
+ unregisterChildren: function (nodeList) {
+ var nodes = [];
+ each(nodeList, function (node) {
+ if (node.nodeType) {
+ if (!nodeList.replacements) {
+ nodeMap['delete'](node);
+ }
+ nodes.push(node);
+ } else {
+ push.apply(nodes, nodeLists.unregister(node, true));
+ }
+ });
+ each(nodeList.deepChildren, function (nodeList) {
+ nodeLists.unregister(nodeList, true);
+ });
+ return nodes;
+ },
+ unregister: function (nodeList, isChild) {
+ var nodes = nodeLists.unregisterChildren(nodeList, true);
+ if (nodeList.unregistered) {
+ var unregisteredCallback = nodeList.unregistered;
+ nodeList.replacements = nodeList.unregistered = null;
+ if (!isChild) {
+ var deepChildren = nodeList.parentList && nodeList.parentList.deepChildren;
+ if (deepChildren) {
+ var index = deepChildren.indexOf(nodeList);
+ if (index !== -1) {
+ deepChildren.splice(index, 1);
+ }
+ }
+ }
+ unregisteredCallback();
+ }
+ return nodes;
+ },
+ after: function (oldElements, newFrag) {
+ var last = oldElements[oldElements.length - 1];
+ if (last.nextSibling) {
+ domMutate.insertBefore.call(last.parentNode, newFrag, last.nextSibling);
+ } else {
+ domMutate.appendChild.call(last.parentNode, newFrag);
+ }
+ },
+ replace: function (oldElements, newFrag) {
+ var selectedValue, parentNode = oldElements[0].parentNode;
+ if (parentNode.nodeName.toUpperCase() === 'SELECT' && parentNode.selectedIndex >= 0) {
+ selectedValue = parentNode.value;
+ }
+ if (oldElements.length === 1) {
+ domMutate.replaceChild.call(parentNode, newFrag, oldElements[0]);
+ } else {
+ nodeLists.after(oldElements, newFrag);
+ nodeLists.remove(oldElements);
+ }
+ if (selectedValue !== undefined) {
+ parentNode.value = selectedValue;
+ }
+ },
+ remove: function (elementsToBeRemoved) {
+ var parent = elementsToBeRemoved[0] && elementsToBeRemoved[0].parentNode;
+ each(elementsToBeRemoved, function (child) {
+ domMutate.removeChild.call(parent, child);
+ });
+ },
+ nodeMap: nodeMap
+ };
+ module.exports = namespace.nodeLists = nodeLists;
+});
+/*can-util@3.10.18#dom/fragment/fragment*/
+define('can-util/dom/fragment/fragment', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/document/document',
+ 'can-util/dom/child-nodes/child-nodes'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var getDocument = require('can-globals/document/document'), childNodes = require('can-util/dom/child-nodes/child-nodes');
+ var fragmentRE = /^\s*<(\w+)[^>]*>/, toString = {}.toString, fragment = function (html, name, doc) {
+ if (name === undefined) {
+ name = fragmentRE.test(html) && RegExp.$1;
+ }
+ if (html && toString.call(html.replace) === '[object Function]') {
+ html = html.replace(/<(?!area|br|col|embed|hr|img|input|link|meta|param)(([\w:]+)[^>]*)\/>/gi, '<$1>');
+ }
+ var container = doc.createElement('div'), temp = doc.createElement('div');
+ if (name === 'tbody' || name === 'tfoot' || name === 'thead' || name === 'colgroup') {
+ temp.innerHTML = '';
+ container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild;
+ } else if (name === 'col') {
+ temp.innerHTML = '';
+ container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild.firstChild;
+ } else if (name === 'tr') {
+ temp.innerHTML = '';
+ container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild.firstChild;
+ } else if (name === 'td' || name === 'th') {
+ temp.innerHTML = '';
+ container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild.firstChild.firstChild;
+ } else if (name === 'option') {
+ temp.innerHTML = '';
+ container = temp.firstChild.nodeType === 3 ? temp.lastChild : temp.firstChild;
+ } else {
+ container.innerHTML = '' + html;
+ }
+ var tmp = {}, children = childNodes(container);
+ tmp.length = children.length;
+ for (var i = 0; i < children.length; i++) {
+ tmp[i] = children[i];
+ }
+ return [].slice.call(tmp);
+ };
+ var buildFragment = function (html, doc) {
+ if (html && html.nodeType === 11) {
+ return html;
+ }
+ if (!doc) {
+ doc = getDocument();
+ } else if (doc.length) {
+ doc = doc[0];
+ }
+ var parts = fragment(html, undefined, doc), frag = (doc || document).createDocumentFragment();
+ for (var i = 0, length = parts.length; i < length; i++) {
+ frag.appendChild(parts[i]);
+ }
+ return frag;
+ };
+ module.exports = buildFragment;
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/frag/frag*/
+define('can-util/dom/frag/frag', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/document/document',
+ 'can-util/dom/fragment/fragment',
+ 'can-util/js/each/each',
+ 'can-util/dom/child-nodes/child-nodes'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var getDocument = require('can-globals/document/document');
+ var fragment = require('can-util/dom/fragment/fragment');
+ var each = require('can-util/js/each/each');
+ var childNodes = require('can-util/dom/child-nodes/child-nodes');
+ var makeFrag = function (item, doc) {
+ var document = doc || getDocument();
+ var frag;
+ if (!item || typeof item === 'string') {
+ frag = fragment(item == null ? '' : '' + item, document);
+ if (!frag.childNodes.length) {
+ frag.appendChild(document.createTextNode(''));
+ }
+ return frag;
+ } else if (item.nodeType === 11) {
+ return item;
+ } else if (typeof item.nodeType === 'number') {
+ frag = document.createDocumentFragment();
+ frag.appendChild(item);
+ return frag;
+ } else if (typeof item.length === 'number') {
+ frag = document.createDocumentFragment();
+ each(item, function (item) {
+ frag.appendChild(makeFrag(item));
+ });
+ if (!childNodes(frag).length) {
+ frag.appendChild(document.createTextNode(''));
+ }
+ return frag;
+ } else {
+ frag = fragment('' + item, document);
+ if (!childNodes(frag).length) {
+ frag.appendChild(document.createTextNode(''));
+ }
+ return frag;
+ }
+ };
+ module.exports = makeFrag;
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/is-of-global-document/is-of-global-document*/
+define('can-util/dom/is-of-global-document/is-of-global-document', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/document/document'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var getDocument = require('can-globals/document/document');
+ module.exports = function (el) {
+ return (el.ownerDocument || el) === getDocument();
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/events/make-mutation-event/make-mutation-event*/
+define('can-util/dom/events/make-mutation-event/make-mutation-event', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/events',
+ 'can-util/dom/data/data',
+ 'can-globals/mutation-observer/mutation-observer',
+ 'can-util/dom/dispatch/dispatch',
+ 'can-util/dom/mutation-observer/document/document',
+ 'can-globals/document/document',
+ 'can-cid/map/map',
+ 'can-util/js/string/string',
+ 'can-util/dom/is-of-global-document/is-of-global-document'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var events = require('can-util/dom/events/events');
+ var domData = require('can-util/dom/data/data');
+ var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
+ var domDispatch = require('can-util/dom/dispatch/dispatch');
+ var mutationDocument = require('can-util/dom/mutation-observer/document/document');
+ var getDocument = require('can-globals/document/document');
+ var CIDMap = require('can-cid/map/map');
+ var string = require('can-util/js/string/string');
+ require('can-util/dom/is-of-global-document/is-of-global-document');
+ module.exports = function (specialEventName, mutationNodesProperty) {
+ var originalAdd = events.addEventListener, originalRemove = events.removeEventListener;
+ events.addEventListener = function (eventName) {
+ if (eventName === specialEventName && getMutationObserver()) {
+ var documentElement = getDocument().documentElement;
+ var specialEventData = domData.get.call(documentElement, specialEventName + 'Data');
+ if (!specialEventData) {
+ specialEventData = {
+ handler: function (mutatedNode) {
+ if (specialEventData.nodeIdsRespondingToInsert.has(mutatedNode)) {
+ domDispatch.call(mutatedNode, specialEventName, [], false);
+ specialEventData.nodeIdsRespondingToInsert.delete(mutatedNode);
+ }
+ },
+ nodeIdsRespondingToInsert: new CIDMap()
+ };
+ mutationDocument['on' + string.capitalize(mutationNodesProperty)](specialEventData.handler);
+ domData.set.call(documentElement, specialEventName + 'Data', specialEventData);
+ }
+ if (this.nodeType !== 11) {
+ var count = specialEventData.nodeIdsRespondingToInsert.get(this) || 0;
+ specialEventData.nodeIdsRespondingToInsert.set(this, count + 1);
+ }
+ }
+ return originalAdd.apply(this, arguments);
+ };
+ events.removeEventListener = function (eventName) {
+ if (eventName === specialEventName && getMutationObserver()) {
+ var documentElement = getDocument().documentElement;
+ var specialEventData = domData.get.call(documentElement, specialEventName + 'Data');
+ if (specialEventData) {
+ var newCount = specialEventData.nodeIdsRespondingToInsert.get(this) - 1;
+ if (newCount) {
+ specialEventData.nodeIdsRespondingToInsert.set(this, newCount);
+ } else {
+ specialEventData.nodeIdsRespondingToInsert.delete(this);
+ }
+ if (!specialEventData.nodeIdsRespondingToInsert.size) {
+ mutationDocument['off' + string.capitalize(mutationNodesProperty)](specialEventData.handler);
+ domData.clean.call(documentElement, specialEventName + 'Data');
+ }
+ }
+ }
+ return originalRemove.apply(this, arguments);
+ };
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/events/removed/removed*/
+define('can-util/dom/events/removed/removed', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/make-mutation-event/make-mutation-event'
+], function (require, exports, module) {
+ 'use strict';
+ var makeMutationEvent = require('can-util/dom/events/make-mutation-event/make-mutation-event');
+ makeMutationEvent('removed', 'removedNodes');
+});
+/*can-view-live@3.2.5#lib/core*/
+define('can-view-live/lib/core', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-parser',
+ 'can-util/dom/events/events',
+ 'can-view-nodelist',
+ 'can-util/dom/frag/frag',
+ 'can-util/dom/child-nodes/child-nodes',
+ 'can-reflect',
+ 'can-util/dom/events/removed/removed'
+], function (require, exports, module) {
+ var parser = require('can-view-parser');
+ var domEvents = require('can-util/dom/events/events');
+ var nodeLists = require('can-view-nodelist');
+ var makeFrag = require('can-util/dom/frag/frag');
+ var childNodes = require('can-util/dom/child-nodes/child-nodes');
+ var canReflect = require('can-reflect');
+ require('can-util/dom/events/removed/removed');
+ var childMutationCallbacks = {};
+ var live = {
+ setup: function (el, bind, unbind) {
+ var tornDown = false, teardown = function () {
+ if (!tornDown) {
+ tornDown = true;
+ unbind(data);
+ domEvents.removeEventListener.call(el, 'removed', teardown);
+ }
+ return true;
+ }, data = {
+ teardownCheck: function (parent) {
+ return parent ? false : teardown();
+ }
+ };
+ domEvents.addEventListener.call(el, 'removed', teardown);
+ bind(data);
+ return data;
+ },
+ listen: function (el, compute, change) {
+ return live.setup(el, function () {
+ canReflect.onValue(compute, change);
+ }, function (data) {
+ canReflect.offValue(compute, change);
+ if (data.nodeList) {
+ nodeLists.unregister(data.nodeList);
+ }
+ });
+ },
+ getAttributeParts: function (newVal) {
+ var attrs = {}, attr;
+ parser.parseAttrs(newVal, {
+ attrStart: function (name) {
+ attrs[name] = '';
+ attr = name;
+ },
+ attrValue: function (value) {
+ attrs[attr] += value;
+ },
+ attrEnd: function () {
+ }
+ });
+ return attrs;
+ },
+ isNode: function (obj) {
+ return obj && obj.nodeType;
+ },
+ addTextNodeIfNoChildren: function (frag) {
+ if (!frag.firstChild) {
+ frag.appendChild(frag.ownerDocument.createTextNode(''));
+ }
+ },
+ registerChildMutationCallback: function (tag, callback) {
+ if (callback) {
+ childMutationCallbacks[tag] = callback;
+ } else {
+ return childMutationCallbacks[tag];
+ }
+ },
+ callChildMutationCallback: function (el) {
+ var callback = el && childMutationCallbacks[el.nodeName.toLowerCase()];
+ if (callback) {
+ callback(el);
+ }
+ },
+ replace: function (nodes, val, teardown) {
+ var oldNodes = nodes.slice(0), frag = makeFrag(val);
+ nodeLists.register(nodes, teardown);
+ nodeLists.update(nodes, childNodes(frag));
+ nodeLists.replace(oldNodes, frag);
+ return nodes;
+ },
+ getParentNode: function (el, defaultParentNode) {
+ return defaultParentNode && el.parentNode.nodeType === 11 ? defaultParentNode : el.parentNode;
+ },
+ makeString: function (txt) {
+ return txt == null ? '' : '' + txt;
+ }
+ };
+ module.exports = live;
+});
+/*can-util@3.10.18#js/diff/diff*/
+define('can-util/js/diff/diff', function (require, exports, module) {
+ 'use strict';
+ var slice = [].slice;
+ var defaultIdentity = function (a, b) {
+ return a === b;
+ };
+ function reverseDiff(oldDiffStopIndex, newDiffStopIndex, oldList, newList, identity) {
+ var oldIndex = oldList.length - 1, newIndex = newList.length - 1;
+ while (oldIndex > oldDiffStopIndex && newIndex > newDiffStopIndex) {
+ var oldItem = oldList[oldIndex], newItem = newList[newIndex];
+ if (identity(oldItem, newItem)) {
+ oldIndex--;
+ newIndex--;
+ continue;
+ } else {
+ return [{
+ index: newDiffStopIndex,
+ deleteCount: oldIndex - oldDiffStopIndex + 1,
+ insert: slice.call(newList, newDiffStopIndex, newIndex + 1)
+ }];
+ }
+ }
+ return [{
+ index: newDiffStopIndex,
+ deleteCount: oldIndex - oldDiffStopIndex + 1,
+ insert: slice.call(newList, newDiffStopIndex, newIndex + 1)
+ }];
+ }
+ module.exports = exports = function (oldList, newList, identity) {
+ identity = identity || defaultIdentity;
+ var oldIndex = 0, newIndex = 0, oldLength = oldList.length, newLength = newList.length, patches = [];
+ while (oldIndex < oldLength && newIndex < newLength) {
+ var oldItem = oldList[oldIndex], newItem = newList[newIndex];
+ if (identity(oldItem, newItem)) {
+ oldIndex++;
+ newIndex++;
+ continue;
+ }
+ if (newIndex + 1 < newLength && identity(oldItem, newList[newIndex + 1])) {
+ patches.push({
+ index: newIndex,
+ deleteCount: 0,
+ insert: [newList[newIndex]]
+ });
+ oldIndex++;
+ newIndex += 2;
+ continue;
+ } else if (oldIndex + 1 < oldLength && identity(oldList[oldIndex + 1], newItem)) {
+ patches.push({
+ index: newIndex,
+ deleteCount: 1,
+ insert: []
+ });
+ oldIndex += 2;
+ newIndex++;
+ continue;
+ } else {
+ patches.push.apply(patches, reverseDiff(oldIndex, newIndex, oldList, newList, identity));
+ return patches;
+ }
+ }
+ if (newIndex === newLength && oldIndex === oldLength) {
+ return patches;
+ }
+ patches.push({
+ index: newIndex,
+ deleteCount: oldLength - oldIndex,
+ insert: slice.call(newList, newIndex)
+ });
+ return patches;
+ };
+});
+/*can-util@3.10.18#dom/events/attributes/attributes*/
+define('can-util/dom/events/attributes/attributes', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/events',
+ 'can-util/dom/is-of-global-document/is-of-global-document',
+ 'can-util/dom/data/data',
+ 'can-globals/mutation-observer/mutation-observer',
+ 'can-assign',
+ 'can-util/dom/dispatch/dispatch'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var events = require('can-util/dom/events/events');
+ var isOfGlobalDocument = require('can-util/dom/is-of-global-document/is-of-global-document');
+ var domData = require('can-util/dom/data/data');
+ var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
+ var assign = require('can-assign');
+ var domDispatch = require('can-util/dom/dispatch/dispatch');
+ var originalAdd = events.addEventListener, originalRemove = events.removeEventListener;
+ events.addEventListener = function (eventName) {
+ if (eventName === 'attributes') {
+ var MutationObserver = getMutationObserver();
+ if (isOfGlobalDocument(this) && MutationObserver) {
+ var existingObserver = domData.get.call(this, 'canAttributesObserver');
+ if (!existingObserver) {
+ var self = this;
+ var observer = new MutationObserver(function (mutations) {
+ mutations.forEach(function (mutation) {
+ var copy = assign({}, mutation);
+ domDispatch.call(self, copy, [], false);
+ });
+ });
+ observer.observe(this, {
+ attributes: true,
+ attributeOldValue: true
+ });
+ domData.set.call(this, 'canAttributesObserver', observer);
+ }
+ } else {
+ domData.set.call(this, 'canHasAttributesBindings', true);
+ }
+ }
+ return originalAdd.apply(this, arguments);
+ };
+ events.removeEventListener = function (eventName) {
+ if (eventName === 'attributes') {
+ var MutationObserver = getMutationObserver();
+ var observer;
+ if (isOfGlobalDocument(this) && MutationObserver) {
+ observer = domData.get.call(this, 'canAttributesObserver');
+ if (observer && observer.disconnect) {
+ observer.disconnect();
+ domData.clean.call(this, 'canAttributesObserver');
+ }
+ } else {
+ domData.clean.call(this, 'canHasAttributesBindings');
+ }
+ }
+ return originalRemove.apply(this, arguments);
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-util@3.10.18#dom/events/inserted/inserted*/
+define('can-util/dom/events/inserted/inserted', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/events/make-mutation-event/make-mutation-event'
+], function (require, exports, module) {
+ 'use strict';
+ var makeMutationEvent = require('can-util/dom/events/make-mutation-event/make-mutation-event');
+ makeMutationEvent('inserted', 'addedNodes');
+});
+/*can-util@3.10.18#dom/attr/attr*/
+define('can-util/dom/attr/attr', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/js/set-immediate/set-immediate',
+ 'can-globals/document/document',
+ 'can-globals/global/global',
+ 'can-util/dom/is-of-global-document/is-of-global-document',
+ 'can-util/dom/data/data',
+ 'can-util/dom/contains/contains',
+ 'can-util/dom/events/events',
+ 'can-util/dom/dispatch/dispatch',
+ 'can-globals/mutation-observer/mutation-observer',
+ 'can-util/js/each/each',
+ 'can-types',
+ 'can-util/js/diff/diff',
+ 'can-util/dom/events/attributes/attributes',
+ 'can-util/dom/events/inserted/inserted'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var setImmediate = require('can-util/js/set-immediate/set-immediate');
+ var getDocument = require('can-globals/document/document');
+ var global = require('can-globals/global/global')();
+ var isOfGlobalDocument = require('can-util/dom/is-of-global-document/is-of-global-document');
+ var setData = require('can-util/dom/data/data');
+ var domContains = require('can-util/dom/contains/contains');
+ var domEvents = require('can-util/dom/events/events');
+ var domDispatch = require('can-util/dom/dispatch/dispatch');
+ var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
+ var each = require('can-util/js/each/each');
+ var types = require('can-types');
+ var diff = require('can-util/js/diff/diff');
+ require('can-util/dom/events/attributes/attributes');
+ require('can-util/dom/events/inserted/inserted');
+ var namespaces = { 'xlink': 'http://www.w3.org/1999/xlink' };
+ var formElements = {
+ 'INPUT': true,
+ 'TEXTAREA': true,
+ 'SELECT': true
+ }, toString = function (value) {
+ if (value == null) {
+ return '';
+ } else {
+ return '' + value;
+ }
+ }, isSVG = function (el) {
+ return el.namespaceURI === 'http://www.w3.org/2000/svg';
+ }, truthy = function () {
+ return true;
+ }, getSpecialTest = function (special) {
+ return special && special.test || truthy;
+ }, propProp = function (prop, obj) {
+ obj = obj || {};
+ obj.get = function () {
+ return this[prop];
+ };
+ obj.set = function (value) {
+ if (this[prop] !== value) {
+ this[prop] = value;
+ }
+ return value;
+ };
+ return obj;
+ }, booleanProp = function (prop) {
+ return {
+ isBoolean: true,
+ set: function (value) {
+ if (prop in this) {
+ this[prop] = value !== false;
+ } else {
+ this.setAttribute(prop, '');
+ }
+ },
+ remove: function () {
+ this[prop] = false;
+ }
+ };
+ }, setupMO = function (el, callback) {
+ var attrMO = setData.get.call(el, 'attrMO');
+ if (!attrMO) {
+ var onMutation = function () {
+ callback.call(el);
+ };
+ var MO = getMutationObserver();
+ if (MO) {
+ var observer = new MO(onMutation);
+ observer.observe(el, {
+ childList: true,
+ subtree: true
+ });
+ setData.set.call(el, 'attrMO', observer);
+ } else {
+ setData.set.call(el, 'attrMO', true);
+ setData.set.call(el, 'canBindingCallback', { onMutation: onMutation });
+ }
+ }
+ }, _findOptionToSelect = function (parent, value) {
+ var child = parent.firstChild;
+ while (child) {
+ if (child.nodeName === 'OPTION' && value === child.value) {
+ return child;
+ }
+ if (child.nodeName === 'OPTGROUP') {
+ var groupChild = _findOptionToSelect(child, value);
+ if (groupChild) {
+ return groupChild;
+ }
+ }
+ child = child.nextSibling;
+ }
+ }, setChildOptions = function (el, value) {
+ var option;
+ if (value != null) {
+ option = _findOptionToSelect(el, value);
+ }
+ if (option) {
+ option.selected = true;
+ } else {
+ el.selectedIndex = -1;
+ }
+ }, forEachOption = function (parent, fn) {
+ var child = parent.firstChild;
+ while (child) {
+ if (child.nodeName === 'OPTION') {
+ fn(child);
+ }
+ if (child.nodeName === 'OPTGROUP') {
+ forEachOption(child, fn);
+ }
+ child = child.nextSibling;
+ }
+ }, collectSelectedOptions = function (parent) {
+ var selectedValues = [];
+ forEachOption(parent, function (option) {
+ if (option.selected) {
+ selectedValues.push(option.value);
+ }
+ });
+ return selectedValues;
+ }, markSelectedOptions = function (parent, values) {
+ forEachOption(parent, function (option) {
+ option.selected = values.indexOf(option.value) !== -1;
+ });
+ }, setChildOptionsOnChange = function (select, aEL) {
+ var handler = setData.get.call(select, 'attrSetChildOptions');
+ if (handler) {
+ return Function.prototype;
+ }
+ handler = function () {
+ setChildOptions(select, select.value);
+ };
+ setData.set.call(select, 'attrSetChildOptions', handler);
+ aEL.call(select, 'change', handler);
+ return function (rEL) {
+ setData.clean.call(select, 'attrSetChildOptions');
+ rEL.call(select, 'change', handler);
+ };
+ }, attr = {
+ special: {
+ checked: {
+ get: function () {
+ return this.checked;
+ },
+ set: function (val) {
+ var notFalse = !!val || val === '' || arguments.length === 0;
+ this.checked = notFalse;
+ if (notFalse && this.type === 'radio') {
+ this.defaultChecked = true;
+ }
+ return val;
+ },
+ remove: function () {
+ this.checked = false;
+ },
+ test: function () {
+ return this.nodeName === 'INPUT';
+ }
+ },
+ 'class': {
+ get: function () {
+ if (isSVG(this)) {
+ return this.getAttribute('class');
+ }
+ return this.className;
+ },
+ set: function (val) {
+ val = val || '';
+ if (isSVG(this)) {
+ this.setAttribute('class', '' + val);
+ } else {
+ this.className = val;
+ }
+ return val;
+ }
+ },
+ disabled: booleanProp('disabled'),
+ focused: {
+ get: function () {
+ return this === document.activeElement;
+ },
+ set: function (val) {
+ var cur = attr.get(this, 'focused');
+ var docEl = this.ownerDocument.documentElement;
+ var element = this;
+ function focusTask() {
+ if (val) {
+ element.focus();
+ } else {
+ element.blur();
+ }
+ }
+ if (cur !== val) {
+ if (!domContains.call(docEl, element)) {
+ var initialSetHandler = function () {
+ domEvents.removeEventListener.call(element, 'inserted', initialSetHandler);
+ focusTask();
+ };
+ domEvents.addEventListener.call(element, 'inserted', initialSetHandler);
+ } else {
+ types.queueTask([
+ focusTask,
+ this,
+ []
+ ]);
+ }
+ }
+ return !!val;
+ },
+ addEventListener: function (eventName, handler, aEL) {
+ aEL.call(this, 'focus', handler);
+ aEL.call(this, 'blur', handler);
+ return function (rEL) {
+ rEL.call(this, 'focus', handler);
+ rEL.call(this, 'blur', handler);
+ };
+ },
+ test: function () {
+ return this.nodeName === 'INPUT';
+ }
+ },
+ 'for': propProp('htmlFor'),
+ innertext: propProp('innerText'),
+ innerhtml: propProp('innerHTML'),
+ innerHTML: propProp('innerHTML', {
+ addEventListener: function (eventName, handler, aEL) {
+ var handlers = [];
+ var el = this;
+ each([
+ 'change',
+ 'blur'
+ ], function (eventName) {
+ var localHandler = function () {
+ handler.apply(this, arguments);
+ };
+ domEvents.addEventListener.call(el, eventName, localHandler);
+ handlers.push([
+ eventName,
+ localHandler
+ ]);
+ });
+ return function (rEL) {
+ each(handlers, function (info) {
+ rEL.call(el, info[0], info[1]);
+ });
+ };
+ }
+ }),
+ required: booleanProp('required'),
+ readonly: booleanProp('readOnly'),
+ selected: {
+ get: function () {
+ return this.selected;
+ },
+ set: function (val) {
+ val = !!val;
+ setData.set.call(this, 'lastSetValue', val);
+ return this.selected = val;
+ },
+ addEventListener: function (eventName, handler, aEL) {
+ var option = this;
+ var select = this.parentNode;
+ var lastVal = option.selected;
+ var localHandler = function (changeEvent) {
+ var curVal = option.selected;
+ lastVal = setData.get.call(option, 'lastSetValue') || lastVal;
+ if (curVal !== lastVal) {
+ lastVal = curVal;
+ domDispatch.call(option, eventName);
+ }
+ };
+ var removeChangeHandler = setChildOptionsOnChange(select, aEL);
+ domEvents.addEventListener.call(select, 'change', localHandler);
+ aEL.call(option, eventName, handler);
+ return function (rEL) {
+ removeChangeHandler(rEL);
+ domEvents.removeEventListener.call(select, 'change', localHandler);
+ rEL.call(option, eventName, handler);
+ };
+ },
+ test: function () {
+ return this.nodeName === 'OPTION' && this.parentNode && this.parentNode.nodeName === 'SELECT';
+ }
+ },
+ src: {
+ set: function (val) {
+ if (val == null || val === '') {
+ this.removeAttribute('src');
+ return null;
+ } else {
+ this.setAttribute('src', val);
+ return val;
+ }
+ }
+ },
+ style: {
+ set: function () {
+ var el = global.document && getDocument().createElement('div');
+ if (el && el.style && 'cssText' in el.style) {
+ return function (val) {
+ return this.style.cssText = val || '';
+ };
+ } else {
+ return function (val) {
+ return this.setAttribute('style', val);
+ };
+ }
+ }()
+ },
+ textcontent: propProp('textContent'),
+ value: {
+ get: function () {
+ var value = this.value;
+ if (this.nodeName === 'SELECT') {
+ if ('selectedIndex' in this && this.selectedIndex === -1) {
+ value = undefined;
+ }
+ }
+ return value;
+ },
+ set: function (value) {
+ var nodeName = this.nodeName.toLowerCase();
+ if (nodeName === 'input') {
+ value = toString(value);
+ }
+ if (this.value !== value || nodeName === 'option') {
+ this.value = value;
+ }
+ if (attr.defaultValue[nodeName]) {
+ this.defaultValue = value;
+ }
+ if (nodeName === 'select') {
+ setData.set.call(this, 'attrValueLastVal', value);
+ setChildOptions(this, value === null ? value : this.value);
+ var docEl = this.ownerDocument.documentElement;
+ if (!domContains.call(docEl, this)) {
+ var select = this;
+ var initialSetHandler = function () {
+ domEvents.removeEventListener.call(select, 'inserted', initialSetHandler);
+ setChildOptions(select, value === null ? value : select.value);
+ };
+ domEvents.addEventListener.call(this, 'inserted', initialSetHandler);
+ }
+ setupMO(this, function () {
+ var value = setData.get.call(this, 'attrValueLastVal');
+ attr.set(this, 'value', value);
+ domDispatch.call(this, 'change');
+ });
+ }
+ return value;
+ },
+ test: function () {
+ return formElements[this.nodeName];
+ }
+ },
+ values: {
+ get: function () {
+ return collectSelectedOptions(this);
+ },
+ set: function (values) {
+ values = values || [];
+ markSelectedOptions(this, values);
+ setData.set.call(this, 'stickyValues', attr.get(this, 'values'));
+ setupMO(this, function () {
+ var previousValues = setData.get.call(this, 'stickyValues');
+ attr.set(this, 'values', previousValues);
+ var currentValues = setData.get.call(this, 'stickyValues');
+ var changes = diff(previousValues.slice().sort(), currentValues.slice().sort());
+ if (changes.length) {
+ domDispatch.call(this, 'values');
+ }
+ });
+ return values;
+ },
+ addEventListener: function (eventName, handler, aEL) {
+ var localHandler = function () {
+ domDispatch.call(this, 'values');
+ };
+ domEvents.addEventListener.call(this, 'change', localHandler);
+ aEL.call(this, eventName, handler);
+ return function (rEL) {
+ domEvents.removeEventListener.call(this, 'change', localHandler);
+ rEL.call(this, eventName, handler);
+ };
+ }
+ }
+ },
+ defaultValue: {
+ input: true,
+ textarea: true
+ },
+ setAttrOrProp: function (el, attrName, val) {
+ attrName = attrName.toLowerCase();
+ var special = attr.special[attrName];
+ if (special && special.isBoolean && !val) {
+ this.remove(el, attrName);
+ } else {
+ this.set(el, attrName, val);
+ }
+ },
+ set: function (el, attrName, val) {
+ var usingMutationObserver = isOfGlobalDocument(el) && getMutationObserver();
+ attrName = attrName.toLowerCase();
+ var oldValue;
+ if (!usingMutationObserver) {
+ oldValue = attr.get(el, attrName);
+ }
+ var newValue;
+ var special = attr.special[attrName];
+ var setter = special && special.set;
+ var test = getSpecialTest(special);
+ if (typeof setter === 'function' && test.call(el)) {
+ if (arguments.length === 2) {
+ newValue = setter.call(el);
+ } else {
+ newValue = setter.call(el, val);
+ }
+ } else {
+ attr.setAttribute(el, attrName, val);
+ }
+ if (!usingMutationObserver && newValue !== oldValue) {
+ attr.trigger(el, attrName, oldValue);
+ }
+ },
+ setSelectValue: function (el, value) {
+ attr.set(el, 'value', value);
+ },
+ setAttribute: function () {
+ var doc = getDocument();
+ if (doc && document.createAttribute) {
+ try {
+ doc.createAttribute('{}');
+ } catch (e) {
+ var invalidNodes = {}, attributeDummy = document.createElement('div');
+ return function (el, attrName, val) {
+ var first = attrName.charAt(0), cachedNode, node, attr;
+ if ((first === '{' || first === '(' || first === '*') && el.setAttributeNode) {
+ cachedNode = invalidNodes[attrName];
+ if (!cachedNode) {
+ attributeDummy.innerHTML = '';
+ cachedNode = invalidNodes[attrName] = attributeDummy.childNodes[0].attributes[0];
+ }
+ node = cachedNode.cloneNode();
+ node.value = val;
+ el.setAttributeNode(node);
+ } else {
+ attr = attrName.split(':');
+ if (attr.length !== 1 && namespaces[attr[0]]) {
+ el.setAttributeNS(namespaces[attr[0]], attrName, val);
+ } else {
+ el.setAttribute(attrName, val);
+ }
+ }
+ };
+ }
+ }
+ return function (el, attrName, val) {
+ el.setAttribute(attrName, val);
+ };
+ }(),
+ trigger: function (el, attrName, oldValue) {
+ if (setData.get.call(el, 'canHasAttributesBindings')) {
+ attrName = attrName.toLowerCase();
+ return setImmediate(function () {
+ domDispatch.call(el, {
+ type: 'attributes',
+ attributeName: attrName,
+ target: el,
+ oldValue: oldValue,
+ bubbles: false
+ }, []);
+ });
+ }
+ },
+ get: function (el, attrName) {
+ attrName = attrName.toLowerCase();
+ var special = attr.special[attrName];
+ var getter = special && special.get;
+ var test = getSpecialTest(special);
+ if (typeof getter === 'function' && test.call(el)) {
+ return getter.call(el);
+ } else {
+ return el.getAttribute(attrName);
+ }
+ },
+ remove: function (el, attrName) {
+ attrName = attrName.toLowerCase();
+ var oldValue;
+ if (!getMutationObserver()) {
+ oldValue = attr.get(el, attrName);
+ }
+ var special = attr.special[attrName];
+ var setter = special && special.set;
+ var remover = special && special.remove;
+ var test = getSpecialTest(special);
+ if (typeof remover === 'function' && test.call(el)) {
+ remover.call(el);
+ } else if (typeof setter === 'function' && test.call(el)) {
+ setter.call(el, undefined);
+ } else {
+ el.removeAttribute(attrName);
+ }
+ if (!getMutationObserver() && oldValue != null) {
+ attr.trigger(el, attrName, oldValue);
+ }
+ },
+ has: function () {
+ var el = getDocument() && document.createElement('div');
+ if (el && el.hasAttribute) {
+ return function (el, name) {
+ return el.hasAttribute(name);
+ };
+ } else {
+ return function (el, name) {
+ return el.getAttribute(name) !== null;
+ };
+ }
+ }()
+ };
+ var oldAddEventListener = domEvents.addEventListener;
+ domEvents.addEventListener = function (eventName, handler) {
+ var special = attr.special[eventName];
+ if (special && special.addEventListener) {
+ var teardown = special.addEventListener.call(this, eventName, handler, oldAddEventListener);
+ var teardowns = setData.get.call(this, 'attrTeardowns');
+ if (!teardowns) {
+ setData.set.call(this, 'attrTeardowns', teardowns = {});
+ }
+ if (!teardowns[eventName]) {
+ teardowns[eventName] = [];
+ }
+ teardowns[eventName].push({
+ teardown: teardown,
+ handler: handler
+ });
+ return;
+ }
+ return oldAddEventListener.apply(this, arguments);
+ };
+ var oldRemoveEventListener = domEvents.removeEventListener;
+ domEvents.removeEventListener = function (eventName, handler) {
+ var special = attr.special[eventName];
+ if (special && special.addEventListener) {
+ var teardowns = setData.get.call(this, 'attrTeardowns');
+ if (teardowns && teardowns[eventName]) {
+ var eventTeardowns = teardowns[eventName];
+ for (var i = 0, len = eventTeardowns.length; i < len; i++) {
+ if (eventTeardowns[i].handler === handler) {
+ eventTeardowns[i].teardown.call(this, oldRemoveEventListener);
+ eventTeardowns.splice(i, 1);
+ break;
+ }
+ }
+ if (eventTeardowns.length === 0) {
+ delete teardowns[eventName];
+ }
+ }
+ return;
+ }
+ return oldRemoveEventListener.apply(this, arguments);
+ };
+ module.exports = exports = attr;
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-view-live@3.2.5#lib/attr*/
+define('can-view-live/lib/attr', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/attr/attr',
+ 'can-view-live/lib/core',
+ 'can-reflect'
+], function (require, exports, module) {
+ var attr = require('can-util/dom/attr/attr');
+ var live = require('can-view-live/lib/core');
+ var canReflect = require('can-reflect');
+ live.attr = function (el, attributeName, compute) {
+ live.listen(el, compute, function (newVal) {
+ attr.set(el, attributeName, newVal);
+ });
+ attr.set(el, attributeName, canReflect.getValue(compute));
+ };
+});
+/*can-util@3.10.18#js/global/global*/
+define('can-util/js/global/global', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/global/global'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ module.exports = require('can-globals/global/global');
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-view-callbacks@3.2.3#can-view-callbacks*/
+define('can-view-callbacks', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-observation',
+ 'can-util/js/dev/dev',
+ 'can-util/js/global/global',
+ 'can-util/dom/mutate/mutate',
+ 'can-namespace'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ var Observation = require('can-observation');
+ var dev = require('can-util/js/dev/dev');
+ var getGlobal = require('can-util/js/global/global');
+ var domMutate = require('can-util/dom/mutate/mutate');
+ var namespace = require('can-namespace');
+ var attr = function (attributeName, attrHandler) {
+ if (attrHandler) {
+ if (typeof attributeName === 'string') {
+ attributes[attributeName] = attrHandler;
+ } else {
+ regExpAttributes.push({
+ match: attributeName,
+ handler: attrHandler
+ });
+ }
+ } else {
+ var cb = attributes[attributeName];
+ if (!cb) {
+ for (var i = 0, len = regExpAttributes.length; i < len; i++) {
+ var attrMatcher = regExpAttributes[i];
+ if (attrMatcher.match.test(attributeName)) {
+ return attrMatcher.handler;
+ }
+ }
+ }
+ return cb;
+ }
+ };
+ var attributes = {}, regExpAttributes = [], automaticCustomElementCharacters = /[-\:]/;
+ var defaultCallback = function () {
+ };
+ var tag = function (tagName, tagHandler) {
+ if (tagHandler) {
+ var GLOBAL = getGlobal();
+ if (GLOBAL.html5) {
+ GLOBAL.html5.elements += ' ' + tagName;
+ GLOBAL.html5.shivDocument();
+ }
+ tags[tagName.toLowerCase()] = tagHandler;
+ } else {
+ var cb;
+ if (tagHandler === null) {
+ delete tags[tagName.toLowerCase()];
+ } else {
+ cb = tags[tagName.toLowerCase()];
+ }
+ if (!cb && automaticCustomElementCharacters.test(tagName)) {
+ cb = defaultCallback;
+ }
+ return cb;
+ }
+ };
+ var tags = {};
+ var callbacks = {
+ _tags: tags,
+ _attributes: attributes,
+ _regExpAttributes: regExpAttributes,
+ defaultCallback: defaultCallback,
+ tag: tag,
+ attr: attr,
+ tagHandler: function (el, tagName, tagData) {
+ var helperTagCallback = tagData.options.get('tags.' + tagName, { proxyMethods: false }), tagCallback = helperTagCallback || tags[tagName];
+ var scope = tagData.scope, res;
+ if (tagCallback) {
+ res = Observation.ignore(tagCallback)(el, tagData);
+ } else {
+ res = scope;
+ }
+ if (res && tagData.subtemplate) {
+ if (scope !== res) {
+ scope = scope.add(res);
+ }
+ var result = tagData.subtemplate(scope, tagData.options);
+ var frag = typeof result === 'string' ? can.view.frag(result) : result;
+ domMutate.appendChild.call(el, frag);
+ }
+ }
+ };
+ namespace.view = namespace.view || {};
+ if (namespace.view.callbacks) {
+ throw new Error('You can\'t have two versions of can-view-callbacks, check your dependencies');
+ } else {
+ module.exports = namespace.view.callbacks = callbacks;
+ }
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-view-live@3.2.5#lib/attrs*/
+define('can-view-live/lib/attrs', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-live/lib/core',
+ 'can-view-callbacks',
+ 'can-util/dom/attr/attr',
+ 'can-util/dom/events/events',
+ 'can-types',
+ 'can-reflect'
+], function (require, exports, module) {
+ var live = require('can-view-live/lib/core');
+ var viewCallbacks = require('can-view-callbacks');
+ var attr = require('can-util/dom/attr/attr');
+ var domEvents = require('can-util/dom/events/events');
+ var types = require('can-types');
+ var canReflect = require('can-reflect');
+ live.attrs = function (el, compute, scope, options) {
+ if (!canReflect.isObservableLike(compute)) {
+ var attrs = live.getAttributeParts(compute);
+ for (var name in attrs) {
+ attr.set(el, name, attrs[name]);
+ }
+ return;
+ }
+ var oldAttrs = {};
+ var setAttrs = function (newVal) {
+ var newAttrs = live.getAttributeParts(newVal), name;
+ for (name in newAttrs) {
+ var newValue = newAttrs[name], oldValue = oldAttrs[name];
+ if (newValue !== oldValue) {
+ attr.set(el, name, newValue);
+ var callback = viewCallbacks.attr(name);
+ if (callback) {
+ callback(el, {
+ attributeName: name,
+ scope: scope,
+ options: options
+ });
+ }
+ }
+ delete oldAttrs[name];
+ }
+ for (name in oldAttrs) {
+ attr.remove(el, name);
+ }
+ oldAttrs = newAttrs;
+ };
+ var handler = function (newVal) {
+ setAttrs(newVal);
+ };
+ canReflect.onValue(compute, handler);
+ var teardownHandler = function () {
+ canReflect.offValue(compute, handler);
+ domEvents.removeEventListener.call(el, 'removed', teardownHandler);
+ };
+ domEvents.addEventListener.call(el, 'removed', teardownHandler);
+ setAttrs(canReflect.getValue(compute));
+ };
+});
+/*can-view-live@3.2.5#lib/html*/
+define('can-view-live/lib/html', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-live/lib/core',
+ 'can-view-nodelist',
+ 'can-util/dom/frag/frag',
+ 'can-util/js/make-array/make-array',
+ 'can-util/dom/child-nodes/child-nodes',
+ 'can-reflect'
+], function (require, exports, module) {
+ var live = require('can-view-live/lib/core');
+ var nodeLists = require('can-view-nodelist');
+ var makeFrag = require('can-util/dom/frag/frag');
+ var makeArray = require('can-util/js/make-array/make-array');
+ var childNodes = require('can-util/dom/child-nodes/child-nodes');
+ var canReflect = require('can-reflect');
+ live.html = function (el, compute, parentNode, nodeList) {
+ var data, makeAndPut, nodes;
+ parentNode = live.getParentNode(el, parentNode);
+ data = live.listen(parentNode, compute, function (newVal) {
+ var attached = nodeLists.first(nodes).parentNode;
+ if (attached) {
+ makeAndPut(newVal);
+ }
+ var pn = nodeLists.first(nodes).parentNode;
+ data.teardownCheck(pn);
+ live.callChildMutationCallback(pn);
+ });
+ nodes = nodeList || [el];
+ makeAndPut = function (val) {
+ var isFunction = typeof val === 'function', frag = makeFrag(isFunction ? '' : val), oldNodes = makeArray(nodes);
+ live.addTextNodeIfNoChildren(frag);
+ oldNodes = nodeLists.update(nodes, childNodes(frag));
+ if (isFunction) {
+ val(frag.firstChild);
+ }
+ nodeLists.replace(oldNodes, frag);
+ };
+ data.nodeList = nodes;
+ if (!nodeList) {
+ nodeLists.register(nodes, data.teardownCheck);
+ } else {
+ nodeList.unregistered = data.teardownCheck;
+ }
+ makeAndPut(canReflect.getValue(compute));
+ };
+});
+/*can-view-live@3.2.5#lib/util/queueFns*/
+define('can-view-live/lib/util/queueFns', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-observation'
+], function (require, exports, module) {
+ var Observation = require('can-observation');
+ module.exports = function queueFns(fns, primaryDepth) {
+ var updateQueue = [], queuedFns = {};
+ var updateQueueObservation = {
+ needsUpdate: false,
+ update: function () {
+ for (var i = 0; i < updateQueue.length; i++) {
+ var obj = updateQueue[i];
+ obj.fn.apply(obj.context, obj.args);
+ }
+ updateQueue = [];
+ },
+ getPrimaryDepth: function () {
+ return primaryDepth || 0;
+ }
+ };
+ var wrapFn = function (fn) {
+ return function () {
+ updateQueue.push({
+ fn: fn,
+ context: this,
+ args: arguments
+ });
+ updateQueueObservation.needsUpdate = false;
+ Observation.registerUpdate(updateQueueObservation);
+ };
+ };
+ for (var key in fns) {
+ queuedFns[key] = wrapFn(fns[key]);
+ }
+ queuedFns.clear = function () {
+ updateQueue = [];
+ };
+ return queuedFns;
+ };
+});
+/*can-view-live@3.2.5#lib/list*/
+define('can-view-live/lib/list', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-live/lib/core',
+ 'can-view-live/lib/util/queueFns',
+ 'can-view-nodelist',
+ 'can-compute',
+ 'can-event/batch/batch',
+ 'can-util/dom/frag/frag',
+ 'can-util/dom/mutate/mutate',
+ 'can-util/dom/child-nodes/child-nodes',
+ 'can-util/js/make-array/make-array',
+ 'can-util/js/each/each',
+ 'can-util/js/is-function/is-function',
+ 'can-util/js/diff/diff',
+ 'can-compute/proto-compute',
+ 'can-reflect'
+], function (require, exports, module) {
+ var live = require('can-view-live/lib/core');
+ var queueFns = require('can-view-live/lib/util/queueFns');
+ var nodeLists = require('can-view-nodelist');
+ var makeCompute = require('can-compute');
+ var canBatch = require('can-event/batch/batch');
+ var frag = require('can-util/dom/frag/frag');
+ var domMutate = require('can-util/dom/mutate/mutate');
+ var childNodes = require('can-util/dom/child-nodes/child-nodes');
+ var makeArray = require('can-util/js/make-array/make-array');
+ var each = require('can-util/js/each/each');
+ var isFunction = require('can-util/js/is-function/is-function');
+ var diff = require('can-util/js/diff/diff');
+ var splice = [].splice;
+ var Compute = require('can-compute/proto-compute');
+ var canReflect = require('can-reflect');
+ var renderAndAddToNodeLists = function (newNodeLists, parentNodeList, render, context, args) {
+ var itemNodeList = [];
+ if (parentNodeList) {
+ nodeLists.register(itemNodeList, null, parentNodeList, true);
+ itemNodeList.parentList = parentNodeList;
+ itemNodeList.expression = '#each SUBEXPRESSION';
+ }
+ var itemHTML = render.apply(context, args.concat([itemNodeList])), itemFrag = frag(itemHTML);
+ var children = makeArray(childNodes(itemFrag));
+ if (parentNodeList) {
+ nodeLists.update(itemNodeList, children);
+ newNodeLists.push(itemNodeList);
+ } else {
+ newNodeLists.push(nodeLists.register(children));
+ }
+ return itemFrag;
+ }, removeFromNodeList = function (masterNodeList, index, length) {
+ var removedMappings = masterNodeList.splice(index + 1, length), itemsToRemove = [];
+ each(removedMappings, function (nodeList) {
+ var nodesToRemove = nodeLists.unregister(nodeList);
+ [].push.apply(itemsToRemove, nodesToRemove);
+ });
+ return itemsToRemove;
+ }, addFalseyIfEmpty = function (list, falseyRender, masterNodeList, nodeList) {
+ if (falseyRender && list.length === 0) {
+ var falseyNodeLists = [];
+ var falseyFrag = renderAndAddToNodeLists(falseyNodeLists, nodeList, falseyRender, list, [list]);
+ nodeLists.after([masterNodeList[0]], falseyFrag);
+ masterNodeList.push(falseyNodeLists[0]);
+ }
+ };
+ live.list = function (el, compute, render, context, parentNode, nodeList, falseyRender) {
+ var masterNodeList = nodeList || [el], indexMap = [], afterPreviousEvents = false, isTornDown = false, add = function add(ev, items, index) {
+ if (!afterPreviousEvents) {
+ return;
+ }
+ var frag = text.ownerDocument.createDocumentFragment(), newNodeLists = [], newIndicies = [];
+ each(items, function (item, key) {
+ var itemIndex = new Compute(key + index), itemCompute = new Compute(function (newVal) {
+ if (arguments.length) {
+ if ('set' in list) {
+ list.set(itemIndex.get(), newVal);
+ } else {
+ list.attr(itemIndex.get(), newVal);
+ }
+ } else {
+ return item;
+ }
+ }), itemFrag = renderAndAddToNodeLists(newNodeLists, nodeList, render, context, [
+ itemCompute,
+ itemIndex
+ ]);
+ frag.appendChild(itemFrag);
+ newIndicies.push(itemIndex);
+ });
+ var masterListIndex = index + 1;
+ if (!indexMap.length) {
+ var falseyItemsToRemove = removeFromNodeList(masterNodeList, 0, masterNodeList.length - 1);
+ nodeLists.remove(falseyItemsToRemove);
+ }
+ if (!masterNodeList[masterListIndex]) {
+ nodeLists.after(masterListIndex === 1 ? [text] : [nodeLists.last(masterNodeList[masterListIndex - 1])], frag);
+ } else {
+ var el = nodeLists.first(masterNodeList[masterListIndex]);
+ domMutate.insertBefore.call(el.parentNode, frag, el);
+ }
+ splice.apply(masterNodeList, [
+ masterListIndex,
+ 0
+ ].concat(newNodeLists));
+ splice.apply(indexMap, [
+ index,
+ 0
+ ].concat(newIndicies));
+ for (var i = index + newIndicies.length, len = indexMap.length; i < len; i++) {
+ indexMap[i].set(i);
+ }
+ if (ev.callChildMutationCallback !== false) {
+ live.callChildMutationCallback(text.parentNode);
+ }
+ }, set = function set(ev, newVal, index) {
+ remove({}, { length: 1 }, index, true);
+ add({}, [newVal], index);
+ }, remove = function remove(ev, items, index, duringTeardown, fullTeardown) {
+ if (!afterPreviousEvents) {
+ return;
+ }
+ if (!duringTeardown && data.teardownCheck(text.parentNode)) {
+ return;
+ }
+ if (index < 0) {
+ index = indexMap.length + index;
+ }
+ var itemsToRemove = removeFromNodeList(masterNodeList, index, items.length);
+ indexMap.splice(index, items.length);
+ for (var i = index, len = indexMap.length; i < len; i++) {
+ indexMap[i].set(i);
+ }
+ if (!fullTeardown) {
+ addFalseyIfEmpty(list, falseyRender, masterNodeList, nodeList);
+ nodeLists.remove(itemsToRemove);
+ if (ev.callChildMutationCallback !== false) {
+ live.callChildMutationCallback(text.parentNode);
+ }
+ } else {
+ nodeLists.unregister(masterNodeList);
+ }
+ }, move = function move(ev, item, newIndex, currentIndex) {
+ if (!afterPreviousEvents) {
+ return;
+ }
+ newIndex = newIndex + 1;
+ currentIndex = currentIndex + 1;
+ var referenceNodeList = masterNodeList[newIndex];
+ var movedElements = frag(nodeLists.flatten(masterNodeList[currentIndex]));
+ var referenceElement;
+ if (currentIndex < newIndex) {
+ referenceElement = nodeLists.last(referenceNodeList).nextSibling;
+ } else {
+ referenceElement = nodeLists.first(referenceNodeList);
+ }
+ var parentNode = masterNodeList[0].parentNode;
+ parentNode.insertBefore(movedElements, referenceElement);
+ var temp = masterNodeList[currentIndex];
+ [].splice.apply(masterNodeList, [
+ currentIndex,
+ 1
+ ]);
+ [].splice.apply(masterNodeList, [
+ newIndex,
+ 0,
+ temp
+ ]);
+ newIndex = newIndex - 1;
+ currentIndex = currentIndex - 1;
+ var indexCompute = indexMap[currentIndex];
+ [].splice.apply(indexMap, [
+ currentIndex,
+ 1
+ ]);
+ [].splice.apply(indexMap, [
+ newIndex,
+ 0,
+ indexCompute
+ ]);
+ var i = Math.min(currentIndex, newIndex);
+ var len = indexMap.length;
+ for (i, len; i < len; i++) {
+ indexMap[i].set(i);
+ }
+ if (ev.callChildMutationCallback !== false) {
+ live.callChildMutationCallback(text.parentNode);
+ }
+ }, queuedFns = queueFns({
+ add: add,
+ set: set,
+ remove: remove,
+ move: move
+ }, nodeList && nodeList.nesting), text = el.ownerDocument.createTextNode(''), list, teardownList = function (fullTeardown) {
+ if (list && list.removeEventListener) {
+ list.removeEventListener('add', queuedFns.add);
+ list.removeEventListener('set', queuedFns.set);
+ list.removeEventListener('remove', queuedFns.remove);
+ list.removeEventListener('move', queuedFns.move);
+ }
+ remove({ callChildMutationCallback: !!fullTeardown }, { length: masterNodeList.length - 1 }, 0, true, fullTeardown);
+ queuedFns.clear();
+ }, oldList, updateList = function (newList) {
+ if (isTornDown) {
+ return;
+ }
+ afterPreviousEvents = true;
+ if (newList && oldList) {
+ list = newList || [];
+ var patches = diff(oldList, newList);
+ if (oldList.removeEventListener) {
+ oldList.removeEventListener('add', queuedFns.add);
+ oldList.removeEventListener('set', queuedFns.set);
+ oldList.removeEventListener('remove', queuedFns.remove);
+ oldList.removeEventListener('move', queuedFns.move);
+ }
+ oldList = newList;
+ for (var i = 0, patchLen = patches.length; i < patchLen; i++) {
+ var patch = patches[i];
+ if (patch.deleteCount) {
+ remove({ callChildMutationCallback: false }, { length: patch.deleteCount }, patch.index, true);
+ }
+ if (patch.insert.length) {
+ add({ callChildMutationCallback: false }, patch.insert, patch.index);
+ }
+ }
+ } else {
+ if (oldList) {
+ teardownList();
+ }
+ list = newList || [];
+ oldList = list;
+ add({ callChildMutationCallback: false }, list, 0);
+ addFalseyIfEmpty(list, falseyRender, masterNodeList, nodeList);
+ }
+ live.callChildMutationCallback(text.parentNode);
+ afterPreviousEvents = false;
+ if (list.addEventListener) {
+ list.addEventListener('add', queuedFns.add);
+ list.addEventListener('set', queuedFns.set);
+ list.addEventListener('remove', queuedFns.remove);
+ list.addEventListener('move', queuedFns.move);
+ }
+ canBatch.afterPreviousEvents(function () {
+ afterPreviousEvents = true;
+ });
+ };
+ var isValueLike = canReflect.isValueLike(compute), isObservableLike = canReflect.isObservableLike(compute);
+ parentNode = live.getParentNode(el, parentNode);
+ var data = live.setup(parentNode, function () {
+ if (isValueLike && isObservableLike) {
+ canReflect.onValue(compute, updateList);
+ }
+ }, function () {
+ if (isValueLike && isObservableLike) {
+ canReflect.offValue(compute, updateList);
+ }
+ teardownList(true);
+ });
+ if (!nodeList) {
+ live.replace(masterNodeList, text, data.teardownCheck);
+ } else {
+ nodeLists.replace(masterNodeList, text);
+ nodeLists.update(masterNodeList, [text]);
+ nodeList.unregistered = function () {
+ data.teardownCheck();
+ isTornDown = true;
+ };
+ }
+ updateList(isValueLike ? canReflect.getValue(compute) : compute);
+ };
+});
+/*can-view-live@3.2.5#lib/text*/
+define('can-view-live/lib/text', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-live/lib/core',
+ 'can-view-nodelist',
+ 'can-reflect'
+], function (require, exports, module) {
+ var live = require('can-view-live/lib/core');
+ var nodeLists = require('can-view-nodelist');
+ var canReflect = require('can-reflect');
+ live.text = function (el, compute, parentNode, nodeList) {
+ var parent = live.getParentNode(el, parentNode);
+ var data = live.listen(parent, compute, function (newVal) {
+ if (typeof node.nodeValue !== 'unknown') {
+ node.nodeValue = live.makeString(newVal);
+ }
+ });
+ var node = el.ownerDocument.createTextNode(live.makeString(canReflect.getValue(compute)));
+ if (nodeList) {
+ nodeList.unregistered = data.teardownCheck;
+ data.nodeList = nodeList;
+ nodeLists.update(nodeList, [node]);
+ nodeLists.replace([el], node);
+ } else {
+ data.nodeList = live.replace([el], node, data.teardownCheck);
+ }
+ };
+});
+/*can-view-live@3.2.5#can-view-live*/
+define('can-view-live', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-live/lib/core',
+ 'can-view-live/lib/attr',
+ 'can-view-live/lib/attrs',
+ 'can-view-live/lib/html',
+ 'can-view-live/lib/list',
+ 'can-view-live/lib/text'
+], function (require, exports, module) {
+ var live = require('can-view-live/lib/core');
+ require('can-view-live/lib/attr');
+ require('can-view-live/lib/attrs');
+ require('can-view-live/lib/html');
+ require('can-view-live/lib/list');
+ require('can-view-live/lib/text');
+ module.exports = live;
+});
+/*can-stache@3.14.3#src/utils*/
+define('can-stache/src/utils', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-scope',
+ 'can-observation',
+ 'can-stache-key',
+ 'can-compute',
+ 'can-reflect',
+ 'can-log/dev/dev',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-util/js/each/each',
+ 'can-util/js/is-array-like/is-array-like'
+], function (require, exports, module) {
+ var Scope = require('can-view-scope');
+ var Observation = require('can-observation');
+ var observationReader = require('can-stache-key');
+ var compute = require('can-compute');
+ var canReflect = require('can-reflect');
+ var dev = require('can-log/dev/dev');
+ var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
+ var each = require('can-util/js/each/each');
+ var isArrayLike = require('can-util/js/is-array-like/is-array-like');
+ var Options = Scope.Options;
+ var noop = function () {
+ };
+ module.exports = {
+ isArrayLike: isArrayLike,
+ emptyHandler: function () {
+ },
+ jsonParse: function (str) {
+ if (str[0] === '\'') {
+ return str.substr(1, str.length - 2);
+ } else if (str === 'undefined') {
+ return undefined;
+ } else {
+ return JSON.parse(str);
+ }
+ },
+ mixins: {
+ last: function () {
+ return this.stack[this.stack.length - 1];
+ },
+ add: function (chars) {
+ this.last().add(chars);
+ },
+ subSectionDepth: function () {
+ return this.stack.length - 1;
+ }
+ },
+ convertToScopes: function (helperOptions, scope, options, nodeList, truthyRenderer, falseyRenderer, isStringOnly) {
+ helperOptions.fn = truthyRenderer ? this.makeRendererConvertScopes(truthyRenderer, scope, options, nodeList, isStringOnly) : noop;
+ helperOptions.inverse = falseyRenderer ? this.makeRendererConvertScopes(falseyRenderer, scope, options, nodeList, isStringOnly) : noop;
+ helperOptions.isSection = !!(truthyRenderer || falseyRenderer);
+ },
+ makeRendererConvertScopes: function (renderer, parentScope, parentOptions, nodeList, observeObservables) {
+ var rendererWithScope = function (ctx, opts, parentNodeList) {
+ return renderer(ctx || parentScope, opts, parentNodeList);
+ };
+ var convertedRenderer = function (newScope, newOptions, parentNodeList) {
+ if (newScope !== undefined && !(newScope instanceof Scope)) {
+ if (parentScope) {
+ newScope = parentScope.add(newScope);
+ } else {
+ newScope = Scope.refsScope().add(newScope || {});
+ }
+ }
+ if (newOptions !== undefined && !(newOptions instanceof Options)) {
+ newOptions = parentOptions.add(newOptions);
+ }
+ var result = rendererWithScope(newScope, newOptions || parentOptions, parentNodeList || nodeList);
+ return result;
+ };
+ return observeObservables ? convertedRenderer : Observation.ignore(convertedRenderer);
+ },
+ getItemsStringContent: function (items, isObserveList, helperOptions, options) {
+ var txt = '', len = observationReader.get(items, 'length'), isObservable = canReflect.isObservableLike(items);
+ for (var i = 0; i < len; i++) {
+ var item = isObservable ? compute(items, '' + i) : items[i];
+ txt += helperOptions.fn(item, options);
+ }
+ return txt;
+ },
+ getItemsFragContent: function (items, helperOptions, scope, asVariable) {
+ var result = [], len = observationReader.get(items, 'length'), isObservable = canReflect.isObservableLike(items), hashExprs = helperOptions.exprData && helperOptions.exprData.hashExprs, hashOptions;
+ if (!isEmptyObject(hashExprs)) {
+ hashOptions = {};
+ each(hashExprs, function (exprs, key) {
+ hashOptions[exprs.key] = key;
+ });
+ }
+ for (var i = 0; i < len; i++) {
+ var aliases = {
+ '%index': i,
+ '@index': i
+ };
+ var item = isObservable ? compute(items, '' + i) : items[i];
+ if (asVariable) {
+ aliases[asVariable] = item;
+ }
+ if (!isEmptyObject(hashOptions)) {
+ if (hashOptions.value) {
+ aliases[hashOptions.value] = item;
+ }
+ if (hashOptions.index) {
+ aliases[hashOptions.index] = i;
+ }
+ }
+ result.push(helperOptions.fn(scope.add(aliases, { notContext: true }).add({ index: i }, { special: true }).add(item)));
+ }
+ return result;
+ },
+ Options: Options
+ };
+});
+/*can-util@3.10.18#js/base-url/base-url*/
+define('can-util/js/base-url/base-url', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/global/global',
+ 'can-globals/document/document'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var getGlobal = require('can-globals/global/global');
+ var getDomDocument = require('can-globals/document/document');
+ var setBaseUrl;
+ module.exports = function (setUrl) {
+ if (setUrl !== undefined) {
+ setBaseUrl = setUrl;
+ }
+ if (setBaseUrl !== undefined) {
+ return setBaseUrl;
+ }
+ var global = getGlobal();
+ var domDocument = getDomDocument();
+ if (domDocument && 'baseURI' in domDocument) {
+ return domDocument.baseURI;
+ } else if (global.location) {
+ var href = global.location.href;
+ var lastSlash = href.lastIndexOf('/');
+ return lastSlash !== -1 ? href.substr(0, lastSlash) : href;
+ } else if (typeof process !== 'undefined') {
+ return process.cwd();
+ }
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-parse-uri@1.0.1#can-parse-uri*/
+define('can-parse-uri', function (require, exports, module) {
+ module.exports = function (url) {
+ var m = String(url).replace(/^\s+|\s+$/g, '').match(/^([^:\/?#]+:)?(\/\/(?:[^:@]*(?::[^:@]*)?@)?(([^:\/?#]*)(?::(\d*))?))?([^?#]*)(\?[^#]*)?(#[\s\S]*)?/);
+ return m ? {
+ href: m[0] || '',
+ protocol: m[1] || '',
+ authority: m[2] || '',
+ host: m[3] || '',
+ hostname: m[4] || '',
+ port: m[5] || '',
+ pathname: m[6] || '',
+ search: m[7] || '',
+ hash: m[8] || ''
+ } : null;
+ };
+});
+/*can-util@3.10.18#js/join-uris/join-uris*/
+define('can-util/js/join-uris/join-uris', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-parse-uri'
+], function (require, exports, module) {
+ 'use strict';
+ var parseURI = require('can-parse-uri');
+ module.exports = function (base, href) {
+ function removeDotSegments(input) {
+ var output = [];
+ input.replace(/^(\.\.?(\/|$))+/, '').replace(/\/(\.(\/|$))+/g, '/').replace(/\/\.\.$/, '/../').replace(/\/?[^\/]*/g, function (p) {
+ if (p === '/..') {
+ output.pop();
+ } else {
+ output.push(p);
+ }
+ });
+ return output.join('').replace(/^\//, input.charAt(0) === '/' ? '/' : '');
+ }
+ href = parseURI(href || '');
+ base = parseURI(base || '');
+ return !href || !base ? null : (href.protocol || base.protocol) + (href.protocol || href.authority ? href.authority : base.authority) + removeDotSegments(href.protocol || href.authority || href.pathname.charAt(0) === '/' ? href.pathname : href.pathname ? (base.authority && !base.pathname ? '/' : '') + base.pathname.slice(0, base.pathname.lastIndexOf('/') + 1) + href.pathname : base.pathname) + (href.protocol || href.authority || href.pathname ? href.search : href.search || base.search) + href.hash;
+ };
+});
+/*can-stache@3.14.3#helpers/-debugger*/
+define('can-stache/helpers/-debugger', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-log'
+], function (require, exports, module) {
+ var canLog = require('can-log');
+ function noop() {
+ }
+ ;
+ var resolveValue = noop;
+ var evaluateArgs = noop;
+ var __testing = {};
+ function debuggerHelper(left, right) {
+ canLog.warn('Forgotten {{debugger}} helper');
+ }
+ module.exports = {
+ helper: debuggerHelper,
+ evaluateArgs: evaluateArgs,
+ resolveValue: resolveValue,
+ __testing: __testing
+ };
+});
+/*can-stache@3.14.3#helpers/core*/
+define('can-stache/helpers/core', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-view-live',
+ 'can-view-nodelist',
+ 'can-compute',
+ 'can-stache/src/utils',
+ 'can-util/js/is-function/is-function',
+ 'can-util/js/base-url/base-url',
+ 'can-util/js/join-uris/join-uris',
+ 'can-util/js/each/each',
+ 'can-util/js/assign/assign',
+ 'can-util/js/is-iterable/is-iterable',
+ 'can-log/dev/dev',
+ 'can-symbol',
+ 'can-reflect',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-stache/expressions/hashes',
+ 'can-stache/helpers/-debugger',
+ 'can-observation',
+ 'can-util/dom/data/data'
+], function (require, exports, module) {
+ var live = require('can-view-live');
+ var nodeLists = require('can-view-nodelist');
+ var compute = require('can-compute');
+ var utils = require('can-stache/src/utils');
+ var isFunction = require('can-util/js/is-function/is-function');
+ var getBaseURL = require('can-util/js/base-url/base-url');
+ var joinURIs = require('can-util/js/join-uris/join-uris');
+ var each = require('can-util/js/each/each');
+ var assign = require('can-util/js/assign/assign');
+ var isIterable = require('can-util/js/is-iterable/is-iterable');
+ var dev = require('can-log/dev/dev');
+ var canSymbol = require('can-symbol');
+ var canReflect = require('can-reflect');
+ var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
+ var Hashes = require('can-stache/expressions/hashes');
+ var debuggerHelper = require('can-stache/helpers/-debugger').helper;
+ var Observation = require('can-observation');
+ var domData = require('can-util/dom/data/data');
+ var looksLikeOptions = function (options) {
+ return options && typeof options.fn === 'function' && typeof options.inverse === 'function';
+ };
+ var resolve = function (value) {
+ if (value && canReflect.isValueLike(value)) {
+ return canReflect.getValue(value);
+ } else {
+ return value;
+ }
+ };
+ var resolveHash = function (hash) {
+ var params = {};
+ for (var prop in hash) {
+ params[prop] = resolve(hash[prop]);
+ }
+ return params;
+ };
+ var peek = Observation.ignore(resolve);
+ var helpers = {
+ 'each': {
+ metadata: { isLiveBound: true },
+ fn: function (items) {
+ var args = [].slice.call(arguments), options = args.pop(), argsLen = args.length, argExprs = options.exprData.argExprs, hashExprs = options.exprData.hashExprs, resolved = peek(items), asVariable, hashOptions, aliases, key;
+ if (argsLen === 2 && !(argExprs[1].expr instanceof Hashes) || argsLen === 3 && argExprs[1].key === 'as') {
+ asVariable = args[argsLen - 1];
+ if (typeof asVariable !== 'string') {
+ asVariable = argExprs[argsLen - 1].key;
+ }
+ }
+ if (!isEmptyObject(hashExprs)) {
+ hashOptions = {};
+ each(hashExprs, function (exprs, key) {
+ hashOptions[exprs.key] = key;
+ });
+ }
+ if ((canReflect.isObservableLike(resolved) && canReflect.isListLike(resolved) || utils.isArrayLike(resolved) && canReflect.isValueLike(items)) && !options.stringOnly) {
+ return function (el) {
+ var nodeList = [el];
+ nodeList.expression = 'live.list';
+ nodeLists.register(nodeList, null, options.nodeList, true);
+ nodeLists.update(options.nodeList, [el]);
+ var cb = function (item, index, parentNodeList) {
+ var aliases = {
+ '%index': index,
+ '@index': index
+ };
+ if (asVariable) {
+ aliases[asVariable] = item;
+ }
+ if (!isEmptyObject(hashOptions)) {
+ if (hashOptions.value) {
+ aliases[hashOptions.value] = item;
+ }
+ if (hashOptions.index) {
+ aliases[hashOptions.index] = index;
+ }
+ }
+ return options.fn(options.scope.add(aliases, { notContext: true }).add({ index: index }, { special: true }).add(item), options.options, parentNodeList);
+ };
+ live.list(el, items, cb, options.context, el.parentNode, nodeList, function (list, parentNodeList) {
+ return options.inverse(options.scope.add(list), options.options, parentNodeList);
+ });
+ };
+ }
+ var expr = resolve(items), result;
+ if (!!expr && utils.isArrayLike(expr)) {
+ result = utils.getItemsFragContent(expr, options, options.scope, asVariable);
+ return options.stringOnly ? result.join('') : result;
+ } else if (canReflect.isObservableLike(expr) && canReflect.isMapLike(expr) || expr instanceof Object) {
+ result = [];
+ canReflect.each(expr, function (val, key) {
+ var value = compute(expr, key);
+ aliases = {
+ '%key': key,
+ '@key': key
+ };
+ if (asVariable) {
+ aliases[asVariable] = value;
+ }
+ if (!isEmptyObject(hashOptions)) {
+ if (hashOptions.value) {
+ aliases[hashOptions.value] = value;
+ }
+ if (hashOptions.key) {
+ aliases[hashOptions.key] = key;
+ }
+ }
+ result.push(options.fn(options.scope.add(aliases, { notContext: true }).add({ key: key }, { special: true }).add(value)));
+ });
+ return options.stringOnly ? result.join('') : result;
+ }
+ }
+ },
+ '@index': {
+ fn: function (offset, options) {
+ if (!options) {
+ options = offset;
+ offset = 0;
+ }
+ var index = options.scope.peek('@index');
+ return '' + ((isFunction(index) ? index() : index) + offset);
+ }
+ },
+ 'if': {
+ fn: function (expr, options) {
+ var value;
+ if (expr && expr.isComputed) {
+ value = compute.truthy(expr)();
+ } else {
+ value = !!resolve(expr);
+ }
+ if (value) {
+ return options.fn(options.scope || this);
+ } else {
+ return options.inverse(options.scope || this);
+ }
+ }
+ },
+ 'is': {
+ fn: function () {
+ var lastValue, curValue, options = arguments[arguments.length - 1];
+ if (arguments.length - 2 <= 0) {
+ return options.inverse();
+ }
+ var args = arguments;
+ var callFn = compute(function () {
+ for (var i = 0; i < args.length - 1; i++) {
+ curValue = resolve(args[i]);
+ curValue = isFunction(curValue) ? curValue() : curValue;
+ if (i > 0) {
+ if (curValue !== lastValue) {
+ return false;
+ }
+ }
+ lastValue = curValue;
+ }
+ return true;
+ });
+ return callFn() ? options.fn() : options.inverse();
+ }
+ },
+ 'eq': {
+ fn: function () {
+ return helpers.is.fn.apply(this, arguments);
+ }
+ },
+ 'unless': {
+ fn: function (expr, options) {
+ return helpers['if'].fn.apply(this, [
+ expr,
+ assign(assign({}, options), {
+ fn: options.inverse,
+ inverse: options.fn
+ })
+ ]);
+ }
+ },
+ 'with': {
+ fn: function (expr, options) {
+ var ctx = expr;
+ if (!options) {
+ options = expr;
+ expr = true;
+ ctx = options.hash;
+ } else {
+ expr = resolve(expr);
+ if (options.hash && !isEmptyObject(options.hash)) {
+ ctx = options.scope.add(options.hash).add(ctx);
+ }
+ }
+ return options.fn(ctx || {});
+ }
+ },
+ 'log': {
+ fn: function (options) {
+ var logs = [];
+ each(arguments, function (val) {
+ if (!looksLikeOptions(val)) {
+ logs.push(val);
+ }
+ });
+ if (typeof console !== 'undefined' && console.log) {
+ if (!logs.length) {
+ console.log(options.context);
+ } else {
+ console.log.apply(console, logs);
+ }
+ }
+ }
+ },
+ 'data': {
+ fn: function (attr) {
+ var data = arguments.length === 2 ? this : arguments[1];
+ return function (el) {
+ domData.set.call(el, attr, data || this.context);
+ };
+ }
+ },
+ 'switch': {
+ fn: function (expression, options) {
+ resolve(expression);
+ var found = false;
+ var newOptions = options.helpers.add({
+ 'case': function (value, options) {
+ if (!found && resolve(expression) === resolve(value)) {
+ found = true;
+ return options.fn(options.scope || this);
+ }
+ },
+ 'default': function (options) {
+ if (!found) {
+ return options.fn(options.scope || this);
+ }
+ }
+ });
+ return options.fn(options.scope, newOptions);
+ }
+ },
+ 'joinBase': {
+ fn: function (firstExpr) {
+ var args = [].slice.call(arguments);
+ var options = args.pop();
+ var moduleReference = args.map(function (expr) {
+ var value = resolve(expr);
+ return isFunction(value) ? value() : value;
+ }).join('');
+ var templateModule = options.helpers.peek('helpers.module');
+ var parentAddress = templateModule ? templateModule.uri : undefined;
+ var isRelative = moduleReference[0] === '.';
+ if (isRelative && parentAddress) {
+ return joinURIs(parentAddress, moduleReference);
+ } else {
+ var baseURL = typeof System !== 'undefined' && (System.renderingBaseURL || System.baseURL) || getBaseURL();
+ if (moduleReference[0] !== '/' && baseURL[baseURL.length - 1] !== '/') {
+ baseURL += '/';
+ }
+ return joinURIs(baseURL, moduleReference);
+ }
+ }
+ }
+ };
+ helpers.eachOf = helpers.each;
+ helpers.debugger = { fn: debuggerHelper };
+ var registerHelper = function (name, callback, metadata) {
+ helpers[name] = {
+ metadata: assign({ isHelper: true }, metadata),
+ fn: callback
+ };
+ };
+ var makeSimpleHelper = function (fn) {
+ return function () {
+ var realArgs = [];
+ each(arguments, function (val) {
+ while (val && val.isComputed) {
+ val = val();
+ }
+ realArgs.push(val);
+ });
+ return fn.apply(this, realArgs);
+ };
+ };
+ var registerSimpleHelper = function (name, callback) {
+ registerHelper(name, makeSimpleHelper(callback));
+ };
+ module.exports = {
+ registerHelper: registerHelper,
+ registerSimpleHelper: function () {
+ registerSimpleHelper.apply(this, arguments);
+ },
+ addHelper: registerSimpleHelper,
+ addLiveHelper: function (name, callback) {
+ return registerHelper(name, callback, { isLiveBound: true });
+ },
+ getHelper: function (name, options) {
+ var helper = options && options.get && options.get('helpers.' + name, { proxyMethods: false });
+ if (helper) {
+ helper = { fn: helper };
+ } else {
+ helper = helpers[name];
+ }
+ if (helper) {
+ helper.metadata = assign(helper.metadata || {}, { isHelper: true });
+ return helper;
+ }
+ },
+ resolve: resolve,
+ resolveHash: resolveHash,
+ looksLikeOptions: looksLikeOptions,
+ helpers: assign({}, helpers)
+ };
+});
+/*can-stache@3.14.3#src/lookup-value-or-helper*/
+define('can-stache/src/lookup-value-or-helper', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/src/expression-helpers',
+ 'can-stache/helpers/core'
+], function (require, exports, module) {
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var mustacheHelpers = require('can-stache/helpers/core');
+ function lookupValueOrHelper(key, scope, helperOptions, readOptions) {
+ var scopeKeyData = expressionHelpers.getObservableValue_fromKey(key, scope, readOptions);
+ var result = { value: scopeKeyData };
+ if (key.charAt(0) === '@' && key !== '@index') {
+ key = key.substr(1);
+ }
+ if (scopeKeyData.initialValue === undefined || mustacheHelpers.helpers[key]) {
+ var helper = mustacheHelpers.getHelper(key, helperOptions);
+ result.helper = helper;
+ }
+ return result;
+ }
+ module.exports = lookupValueOrHelper;
+});
+/*can-stache@3.14.3#expressions/lookup*/
+define('can-stache/expressions/lookup', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/src/expression-helpers',
+ 'can-stache/src/lookup-value-or-helper',
+ 'can-util/js/assign/assign'
+], function (require, exports, module) {
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var lookupValueOrHelper = require('can-stache/src/lookup-value-or-helper');
+ var assign = require('can-util/js/assign/assign');
+ var Lookup = function (key, root) {
+ this.key = key;
+ this.rootExpr = root;
+ };
+ Lookup.prototype.value = function (scope, helperOptions) {
+ if (this.rootExpr) {
+ return expressionHelpers.getObservableValue_fromDynamicKey_fromObservable(this.key, this.rootExpr.value(scope, helperOptions), scope, {}, {});
+ } else {
+ var result = lookupValueOrHelper(this.key, scope, helperOptions);
+ assign(this, result.metadata);
+ return result.helper || result.value;
+ }
+ };
+ module.exports = Lookup;
+});
+/*can-stache@3.14.3#expressions/scope-lookup*/
+define('can-stache/expressions/scope-lookup', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/src/expression-helpers',
+ 'can-stache/expressions/lookup'
+], function (require, exports, module) {
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var Lookup = require('can-stache/expressions/lookup');
+ var ScopeLookup = function (key, root) {
+ Lookup.apply(this, arguments);
+ };
+ ScopeLookup.prototype.value = function (scope, helperOptions) {
+ if (this.rootExpr) {
+ return expressionHelpers.getObservableValue_fromDynamicKey_fromObservable(this.key, this.rootExpr.value(scope, helperOptions), scope, {}, {});
+ }
+ return expressionHelpers.getObservableValue_fromKey(this.key, scope, helperOptions);
+ };
+ module.exports = ScopeLookup;
+});
+/*can-stache@3.14.3#expressions/helper*/
+define('can-stache/expressions/helper', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/expressions/literal',
+ 'can-compute',
+ 'can-util/js/assign/assign',
+ 'can-util/js/dev/dev',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-stache/src/expression-helpers',
+ 'can-stache/src/utils',
+ 'can-stache/helpers/core'
+], function (require, exports, module) {
+ var Literal = require('can-stache/expressions/literal');
+ var compute = require('can-compute');
+ var assign = require('can-util/js/assign/assign');
+ var dev = require('can-util/js/dev/dev');
+ var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var utils = require('can-stache/src/utils');
+ var mustacheHelpers = require('can-stache/helpers/core');
+ var Helper = function (methodExpression, argExpressions, hashExpressions) {
+ this.methodExpr = methodExpression;
+ this.argExprs = argExpressions;
+ this.hashExprs = hashExpressions;
+ this.mode = null;
+ };
+ Helper.prototype.args = function (scope, helperOptions) {
+ var args = [];
+ for (var i = 0, len = this.argExprs.length; i < len; i++) {
+ var arg = this.argExprs[i];
+ args.push(expressionHelpers.toComputeOrValue(arg.value.apply(arg, arguments)));
+ }
+ return args;
+ };
+ Helper.prototype.hash = function (scope, helperOptions) {
+ var hash = {};
+ for (var prop in this.hashExprs) {
+ var val = this.hashExprs[prop];
+ hash[prop] = expressionHelpers.toComputeOrValue(val.value.apply(val, arguments));
+ }
+ return hash;
+ };
+ Helper.prototype.helperAndValue = function (scope, helperOptions) {
+ var looksLikeAHelper = this.argExprs.length || !isEmptyObject(this.hashExprs), helper, computeData, methodKey = this.methodExpr instanceof Literal ? '' + this.methodExpr._value : this.methodExpr.key, initialValue, args;
+ if (looksLikeAHelper) {
+ helper = mustacheHelpers.getHelper(methodKey, helperOptions);
+ }
+ if (!helper) {
+ computeData = expressionHelpers.getObservableValue_fromKey(methodKey, scope, { isArgument: true });
+ if (typeof computeData.initialValue === 'function') {
+ args = this.args(scope, helperOptions).map(expressionHelpers.toComputeOrValue);
+ var functionResult = compute(function () {
+ return computeData.initialValue.apply(null, args);
+ });
+ compute.temporarilyBind(functionResult);
+ return { value: functionResult };
+ } else if (typeof computeData.initialValue !== 'undefined') {
+ return { value: computeData };
+ }
+ if (!looksLikeAHelper && initialValue === undefined) {
+ helper = mustacheHelpers.getHelper(methodKey, helperOptions);
+ }
+ }
+ return {
+ value: computeData,
+ args: args,
+ helper: helper && helper.fn
+ };
+ };
+ Helper.prototype.evaluator = function (helper, scope, helperOptions, readOptions, nodeList, truthyRenderer, falseyRenderer, stringOnly) {
+ var helperOptionArg = { stringOnly: stringOnly }, context = scope.peek('.'), args = this.args(scope, helperOptions, nodeList, truthyRenderer, falseyRenderer, stringOnly), hash = this.hash(scope, helperOptions, nodeList, truthyRenderer, falseyRenderer, stringOnly);
+ utils.convertToScopes(helperOptionArg, scope, helperOptions, nodeList, truthyRenderer, falseyRenderer, stringOnly);
+ assign(helperOptionArg, {
+ context: context,
+ scope: scope,
+ contexts: scope,
+ hash: hash,
+ nodeList: nodeList,
+ exprData: this,
+ helperOptions: helperOptions,
+ helpers: helperOptions
+ });
+ args.push(helperOptionArg);
+ return function () {
+ return helper.apply(context, args);
+ };
+ };
+ Helper.prototype.value = function (scope, helperOptions, nodeList, truthyRenderer, falseyRenderer, stringOnly) {
+ var helperAndValue = this.helperAndValue(scope, helperOptions);
+ var helper = helperAndValue.helper;
+ if (!helper) {
+ return helperAndValue.value;
+ }
+ var fn = this.evaluator(helper, scope, helperOptions, nodeList, truthyRenderer, falseyRenderer, stringOnly);
+ var computeValue = compute(fn);
+ compute.temporarilyBind(computeValue);
+ if (!expressionHelpers.computeHasDependencies(computeValue)) {
+ return computeValue();
+ } else {
+ return computeValue;
+ }
+ };
+ Helper.prototype.closingTag = function () {
+ return this.methodExpr.key;
+ };
+ module.exports = Helper;
+});
+/*can-stache@3.14.3#expressions/helper-lookup*/
+define('can-stache/expressions/helper-lookup', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/expressions/lookup',
+ 'can-stache/src/lookup-value-or-helper'
+], function (require, exports, module) {
+ var Lookup = require('can-stache/expressions/lookup');
+ var lookupValueOrHelper = require('can-stache/src/lookup-value-or-helper');
+ var HelperLookup = function () {
+ Lookup.apply(this, arguments);
+ };
+ HelperLookup.prototype.value = function (scope, helperOptions) {
+ var result = lookupValueOrHelper(this.key, scope, helperOptions, {
+ isArgument: true,
+ args: [
+ scope.peek('.'),
+ scope
+ ]
+ });
+ return result.helper || result.value;
+ };
+ module.exports = HelperLookup;
+});
+/*can-stache@3.14.3#expressions/helper-scope-lookup*/
+define('can-stache/expressions/helper-scope-lookup', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/expressions/lookup',
+ 'can-stache/src/expression-helpers'
+], function (require, exports, module) {
+ var Lookup = require('can-stache/expressions/lookup');
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var HelperScopeLookup = function () {
+ Lookup.apply(this, arguments);
+ };
+ HelperScopeLookup.prototype.value = function (scope, helperOptions) {
+ return expressionHelpers.getObservableValue_fromKey(this.key, scope, {
+ callMethodsOnObservables: true,
+ isArgument: true,
+ args: [
+ scope.peek('.'),
+ scope
+ ]
+ });
+ };
+ module.exports = HelperScopeLookup;
+});
+/*can-stache@3.14.3#src/expression*/
+define('can-stache/src/expression', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/expressions/arg',
+ 'can-stache/expressions/literal',
+ 'can-stache/expressions/hashes',
+ 'can-stache/expressions/bracket',
+ 'can-stache/expressions/call',
+ 'can-stache/expressions/scope-lookup',
+ 'can-stache/expressions/helper',
+ 'can-stache/expressions/lookup',
+ 'can-stache/expressions/helper-lookup',
+ 'can-stache/expressions/helper-scope-lookup',
+ 'can-stache/src/set-identifier',
+ 'can-stache/src/expression-helpers',
+ 'can-stache/src/utils',
+ 'can-util/js/each/each',
+ 'can-util/js/assign/assign',
+ 'can-util/js/last/last',
+ 'can-reflect',
+ 'can-symbol'
+], function (require, exports, module) {
+ var Arg = require('can-stache/expressions/arg');
+ var Literal = require('can-stache/expressions/literal');
+ var Hashes = require('can-stache/expressions/hashes');
+ var Bracket = require('can-stache/expressions/bracket');
+ var Call = require('can-stache/expressions/call');
+ var ScopeLookup = require('can-stache/expressions/scope-lookup');
+ var Helper = require('can-stache/expressions/helper');
+ var Lookup = require('can-stache/expressions/lookup');
+ var HelperLookup = require('can-stache/expressions/helper-lookup');
+ var HelperScopeLookup = require('can-stache/expressions/helper-scope-lookup');
+ var SetIdentifier = require('can-stache/src/set-identifier');
+ var expressionHelpers = require('can-stache/src/expression-helpers');
+ var utils = require('can-stache/src/utils');
+ var each = require('can-util/js/each/each');
+ var assign = require('can-util/js/assign/assign');
+ var last = require('can-util/js/last/last');
+ var canReflect = require('can-reflect');
+ var canSymbol = require('can-symbol');
+ var Hash = function () {
+ };
+ var keyRegExp = /[\w\.\\\-_@\/\&%]+/, tokensRegExp = /('.*?'|".*?"|=|[\w\.\\\-_@\/*%\$]+|[\(\)]|,|\~|\[|\]\s*|\s*(?=\[))/g, bracketSpaceRegExp = /\]\s+/, literalRegExp = /^('.*?'|".*?"|[0-9]+\.?[0-9]*|true|false|null|undefined)$/;
+ var isTokenKey = function (token) {
+ return keyRegExp.test(token);
+ };
+ var testDot = /^[\.@]\w/;
+ var isAddingToExpression = function (token) {
+ return isTokenKey(token) && testDot.test(token);
+ };
+ var ensureChildren = function (type) {
+ if (!type.children) {
+ type.children = [];
+ }
+ return type;
+ };
+ var Stack = function () {
+ this.root = {
+ children: [],
+ type: 'Root'
+ };
+ this.current = this.root;
+ this.stack = [this.root];
+ };
+ assign(Stack.prototype, {
+ top: function () {
+ return last(this.stack);
+ },
+ isRootTop: function () {
+ return this.top() === this.root;
+ },
+ popTo: function (types) {
+ this.popUntil(types);
+ this.pop();
+ },
+ pop: function () {
+ if (!this.isRootTop()) {
+ this.stack.pop();
+ }
+ },
+ first: function (types) {
+ var curIndex = this.stack.length - 1;
+ while (curIndex > 0 && types.indexOf(this.stack[curIndex].type) === -1) {
+ curIndex--;
+ }
+ return this.stack[curIndex];
+ },
+ firstParent: function (types) {
+ var curIndex = this.stack.length - 2;
+ while (curIndex > 0 && types.indexOf(this.stack[curIndex].type) === -1) {
+ curIndex--;
+ }
+ return this.stack[curIndex];
+ },
+ popUntil: function (types) {
+ while (types.indexOf(this.top().type) === -1 && !this.isRootTop()) {
+ this.stack.pop();
+ }
+ return this.top();
+ },
+ addTo: function (types, type) {
+ var cur = this.popUntil(types);
+ ensureChildren(cur).children.push(type);
+ },
+ addToAndPush: function (types, type) {
+ this.addTo(types, type);
+ this.stack.push(type);
+ },
+ push: function (type) {
+ this.stack.push(type);
+ },
+ topLastChild: function () {
+ return last(this.top().children);
+ },
+ replaceTopLastChild: function (type) {
+ var children = ensureChildren(this.top()).children;
+ children.pop();
+ children.push(type);
+ return type;
+ },
+ replaceTopLastChildAndPush: function (type) {
+ this.replaceTopLastChild(type);
+ this.stack.push(type);
+ },
+ replaceTopAndPush: function (type) {
+ var children;
+ if (this.top() === this.root) {
+ children = ensureChildren(this.top()).children;
+ } else {
+ this.stack.pop();
+ children = ensureChildren(this.top()).children;
+ }
+ children.pop();
+ children.push(type);
+ this.stack.push(type);
+ return type;
+ }
+ });
+ var convertKeyToLookup = function (key) {
+ var lastPath = key.lastIndexOf('./');
+ var lastDot = key.lastIndexOf('.');
+ if (lastDot > lastPath) {
+ return key.substr(0, lastDot) + '@' + key.substr(lastDot + 1);
+ }
+ var firstNonPathCharIndex = lastPath === -1 ? 0 : lastPath + 2;
+ var firstNonPathChar = key.charAt(firstNonPathCharIndex);
+ if (firstNonPathChar === '.' || firstNonPathChar === '@') {
+ return key.substr(0, firstNonPathCharIndex) + '@' + key.substr(firstNonPathCharIndex + 1);
+ } else {
+ return key.substr(0, firstNonPathCharIndex) + '@' + key.substr(firstNonPathCharIndex);
+ }
+ };
+ var convertToAtLookup = function (ast) {
+ if (ast.type === 'Lookup') {
+ ast.key = convertKeyToLookup(ast.key);
+ }
+ return ast;
+ };
+ var convertToHelperIfTopIsLookup = function (stack) {
+ var top = stack.top();
+ if (top && top.type === 'Lookup') {
+ var base = stack.stack[stack.stack.length - 2];
+ if (base.type !== 'Helper' && base) {
+ stack.replaceTopAndPush({
+ type: 'Helper',
+ method: top
+ });
+ }
+ }
+ };
+ var expression = {
+ toComputeOrValue: expressionHelpers.toComputeOrValue,
+ convertKeyToLookup: convertKeyToLookup,
+ Literal: Literal,
+ Lookup: Lookup,
+ ScopeLookup: ScopeLookup,
+ Arg: Arg,
+ Hash: Hash,
+ Hashes: Hashes,
+ Call: Call,
+ Helper: Helper,
+ HelperLookup: HelperLookup,
+ HelperScopeLookup: HelperScopeLookup,
+ Bracket: Bracket,
+ SetIdentifier: SetIdentifier,
+ tokenize: function (expression) {
+ var tokens = [];
+ (expression.trim() + ' ').replace(tokensRegExp, function (whole, arg) {
+ if (bracketSpaceRegExp.test(arg)) {
+ tokens.push(arg[0]);
+ tokens.push(arg.slice(1));
+ } else {
+ tokens.push(arg);
+ }
+ });
+ return tokens;
+ },
+ lookupRules: {
+ 'default': function (ast, methodType, isArg) {
+ var name = (methodType === 'Helper' && !ast.root ? 'Helper' : '') + (isArg ? 'Scope' : '') + 'Lookup';
+ return expression[name];
+ },
+ 'method': function (ast, methodType, isArg) {
+ return ScopeLookup;
+ }
+ },
+ methodRules: {
+ 'default': function (ast) {
+ return ast.type === 'Call' ? Call : Helper;
+ },
+ 'call': function (ast) {
+ return Call;
+ }
+ },
+ parse: function (expressionString, options) {
+ options = options || {};
+ var ast = this.ast(expressionString);
+ if (!options.lookupRule) {
+ options.lookupRule = 'default';
+ }
+ if (typeof options.lookupRule === 'string') {
+ options.lookupRule = expression.lookupRules[options.lookupRule];
+ }
+ if (!options.methodRule) {
+ options.methodRule = 'default';
+ }
+ if (typeof options.methodRule === 'string') {
+ options.methodRule = expression.methodRules[options.methodRule];
+ }
+ var expr = this.hydrateAst(ast, options, options.baseMethodType || 'Helper');
+ return expr;
+ },
+ hydrateAst: function (ast, options, methodType, isArg) {
+ var hashes;
+ if (ast.type === 'Lookup') {
+ var lookup = new (options.lookupRule(ast, methodType, isArg))(ast.key, ast.root && this.hydrateAst(ast.root, options, methodType));
+ return lookup;
+ } else if (ast.type === 'Literal') {
+ return new Literal(ast.value);
+ } else if (ast.type === 'Arg') {
+ return new Arg(this.hydrateAst(ast.children[0], options, methodType, isArg), { compute: true });
+ } else if (ast.type === 'Hash') {
+ throw new Error('');
+ } else if (ast.type === 'Hashes') {
+ hashes = {};
+ each(ast.children, function (hash) {
+ hashes[hash.prop] = this.hydrateAst(hash.children[0], options, methodType, true);
+ }, this);
+ return new Hashes(hashes);
+ } else if (ast.type === 'Call' || ast.type === 'Helper') {
+ hashes = {};
+ var args = [], children = ast.children, ExpressionType = options.methodRule(ast);
+ if (children) {
+ for (var i = 0; i < children.length; i++) {
+ var child = children[i];
+ if (child.type === 'Hashes' && ast.type === 'Helper' && ExpressionType !== Call) {
+ each(child.children, function (hash) {
+ hashes[hash.prop] = this.hydrateAst(hash.children[0], options, ast.type, true);
+ }, this);
+ } else {
+ args.push(this.hydrateAst(child, options, ast.type, true));
+ }
+ }
+ }
+ return new ExpressionType(this.hydrateAst(ast.method, options, ast.type), args, hashes);
+ } else if (ast.type === 'Bracket') {
+ var originalKey;
+ return new Bracket(this.hydrateAst(ast.children[0], options), ast.root ? this.hydrateAst(ast.root, options) : undefined, originalKey);
+ }
+ },
+ ast: function (expression) {
+ var tokens = this.tokenize(expression);
+ return this.parseAst(tokens, { index: 0 });
+ },
+ parseAst: function (tokens, cursor) {
+ var stack = new Stack(), top, firstParent, lastToken;
+ while (cursor.index < tokens.length) {
+ var token = tokens[cursor.index], nextToken = tokens[cursor.index + 1];
+ cursor.index++;
+ if (nextToken === '=') {
+ top = stack.top();
+ if (top && top.type === 'Lookup') {
+ firstParent = stack.firstParent([
+ 'Call',
+ 'Helper',
+ 'Hash'
+ ]);
+ if (firstParent.type === 'Call' || firstParent.type === 'Root') {
+ stack.popUntil(['Call']);
+ top = stack.top();
+ stack.replaceTopAndPush({
+ type: 'Helper',
+ method: top.type === 'Root' ? last(top.children) : top
+ });
+ }
+ }
+ firstParent = stack.firstParent([
+ 'Call',
+ 'Helper',
+ 'Hashes'
+ ]);
+ var hash = {
+ type: 'Hash',
+ prop: token
+ };
+ if (firstParent.type === 'Hashes') {
+ stack.addToAndPush(['Hashes'], hash);
+ } else {
+ stack.addToAndPush([
+ 'Helper',
+ 'Call'
+ ], {
+ type: 'Hashes',
+ children: [hash]
+ });
+ stack.push(hash);
+ }
+ cursor.index++;
+ } else if (literalRegExp.test(token)) {
+ convertToHelperIfTopIsLookup(stack);
+ firstParent = stack.first([
+ 'Helper',
+ 'Call',
+ 'Hash',
+ 'Bracket'
+ ]);
+ if (firstParent.type === 'Hash' && (firstParent.children && firstParent.children.length > 0)) {
+ stack.addTo([
+ 'Helper',
+ 'Call',
+ 'Bracket'
+ ], {
+ type: 'Literal',
+ value: utils.jsonParse(token)
+ });
+ } else if (firstParent.type === 'Bracket' && (firstParent.children && firstParent.children.length > 0)) {
+ stack.addTo([
+ 'Helper',
+ 'Call',
+ 'Hash'
+ ], {
+ type: 'Literal',
+ value: utils.jsonParse(token)
+ });
+ } else {
+ stack.addTo([
+ 'Helper',
+ 'Call',
+ 'Hash',
+ 'Bracket'
+ ], {
+ type: 'Literal',
+ value: utils.jsonParse(token)
+ });
+ }
+ } else if (keyRegExp.test(token)) {
+ lastToken = stack.topLastChild();
+ firstParent = stack.first([
+ 'Helper',
+ 'Call',
+ 'Hash',
+ 'Bracket'
+ ]);
+ if (lastToken && (lastToken.type === 'Call' || lastToken.type === 'Bracket') && isAddingToExpression(token)) {
+ stack.replaceTopLastChildAndPush({
+ type: 'Lookup',
+ root: lastToken,
+ key: token.slice(1)
+ });
+ } else if (firstParent.type === 'Bracket') {
+ if (!(firstParent.children && firstParent.children.length > 0)) {
+ stack.addToAndPush(['Bracket'], {
+ type: 'Lookup',
+ key: token
+ });
+ } else {
+ if (stack.first([
+ 'Helper',
+ 'Call',
+ 'Hash',
+ 'Arg'
+ ]).type === 'Helper' && token[0] !== '.') {
+ stack.addToAndPush(['Helper'], {
+ type: 'Lookup',
+ key: token
+ });
+ } else {
+ stack.replaceTopAndPush({
+ type: 'Lookup',
+ key: token.slice(1),
+ root: firstParent
+ });
+ }
+ }
+ } else {
+ convertToHelperIfTopIsLookup(stack);
+ stack.addToAndPush([
+ 'Helper',
+ 'Call',
+ 'Hash',
+ 'Arg',
+ 'Bracket'
+ ], {
+ type: 'Lookup',
+ key: token
+ });
+ }
+ } else if (token === '~') {
+ convertToHelperIfTopIsLookup(stack);
+ stack.addToAndPush([
+ 'Helper',
+ 'Call',
+ 'Hash'
+ ], {
+ type: 'Arg',
+ key: token
+ });
+ } else if (token === '(') {
+ top = stack.top();
+ if (top.type === 'Lookup') {
+ stack.replaceTopAndPush({
+ type: 'Call',
+ method: convertToAtLookup(top)
+ });
+ } else {
+ throw new Error('Unable to understand expression ' + tokens.join(''));
+ }
+ } else if (token === ')') {
+ stack.popTo(['Call']);
+ } else if (token === ',') {
+ stack.popUntil(['Call']);
+ } else if (token === '[') {
+ top = stack.top();
+ lastToken = stack.topLastChild();
+ if (lastToken && (lastToken.type === 'Call' || lastToken.type === 'Bracket')) {
+ stack.replaceTopAndPush({
+ type: 'Bracket',
+ root: lastToken
+ });
+ } else if (top.type === 'Lookup' || top.type === 'Bracket') {
+ var bracket = {
+ type: 'Bracket',
+ root: top
+ };
+ stack.replaceTopAndPush(bracket);
+ } else if (top.type === 'Call') {
+ stack.addToAndPush(['Call'], { type: 'Bracket' });
+ } else if (top === ' ') {
+ stack.popUntil(['Lookup']);
+ convertToHelperIfTopIsLookup(stack);
+ stack.addToAndPush([
+ 'Helper',
+ 'Call',
+ 'Hash'
+ ], { type: 'Bracket' });
+ } else {
+ stack.replaceTopAndPush({ type: 'Bracket' });
+ }
+ } else if (token === ']') {
+ stack.pop();
+ } else if (token === ' ') {
+ stack.push(token);
+ }
+ }
+ return stack.root.children[0];
+ }
+ };
+ module.exports = expression;
+});
+/*can-view-model@3.5.2#can-view-model*/
+define('can-view-model', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-util/dom/data/data',
+ 'can-simple-map',
+ 'can-types',
+ 'can-namespace',
+ 'can-globals/document/document',
+ 'can-util/js/is-array-like/is-array-like',
+ 'can-reflect'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var domData = require('can-util/dom/data/data');
+ var SimpleMap = require('can-simple-map');
+ var types = require('can-types');
+ var ns = require('can-namespace');
+ var getDocument = require('can-globals/document/document');
+ var isArrayLike = require('can-util/js/is-array-like/is-array-like');
+ var canReflect = require('can-reflect');
+ module.exports = ns.viewModel = function (el, attr, val) {
+ var scope;
+ if (typeof el === 'string') {
+ el = getDocument().querySelector(el);
+ } else if (isArrayLike(el) && !el.nodeType) {
+ el = el[0];
+ }
+ if (canReflect.isObservableLike(attr) && canReflect.isMapLike(attr)) {
+ return domData.set.call(el, 'viewModel', attr);
+ }
+ scope = domData.get.call(el, 'viewModel');
+ if (!scope) {
+ scope = types.DefaultMap ? new types.DefaultMap() : new SimpleMap();
+ domData.set.call(el, 'viewModel', scope);
+ }
+ switch (arguments.length) {
+ case 0:
+ case 1:
+ return scope;
+ case 2:
+ return 'attr' in scope ? scope.attr(attr) : scope[attr];
+ default:
+ if ('attr' in scope) {
+ scope.attr(attr, val);
+ } else {
+ scope[attr] = val;
+ }
+ return el;
+ }
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-simple-observable@1.0.2#can-simple-observable*/
+define('can-simple-observable', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-reflect',
+ 'can-event/batch/batch',
+ 'can-observation',
+ 'can-cid',
+ 'can-namespace'
+], function (require, exports, module) {
+ var canReflect = require('can-reflect');
+ var canBatch = require('can-event/batch/batch');
+ var Observation = require('can-observation');
+ var CID = require('can-cid');
+ var ns = require('can-namespace');
+ module.exports = ns.simpleObservable = function simpleObservable(initialValue) {
+ var value = initialValue;
+ var handlers = [];
+ var fn = function (newValue) {
+ if (arguments.length) {
+ value = newValue;
+ handlers.forEach(function (handler) {
+ canBatch.queue([
+ handler,
+ fn,
+ [newValue]
+ ]);
+ }, this);
+ } else {
+ Observation.add(fn);
+ return value;
+ }
+ };
+ CID(fn);
+ canReflect.assignSymbols(fn, {
+ 'can.onValue': function (handler) {
+ handlers.push(handler);
+ },
+ 'can.offValue': function (handler) {
+ var index = handlers.indexOf(handler);
+ handlers.splice(index, 1);
+ },
+ 'can.setValue': function (newValue) {
+ return fn(newValue);
+ },
+ 'can.getValue': function () {
+ return fn();
+ }
+ });
+ return fn;
+ };
+});
+/*can-dom-events@1.0.7#helpers/util*/
+define('can-dom-events/helpers/util', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-globals/document/document',
+ 'can-globals/is-browser-window/is-browser-window'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var getCurrentDocument = require('can-globals/document/document');
+ var isBrowserWindow = require('can-globals/is-browser-window/is-browser-window');
+ function getTargetDocument(target) {
+ return target.ownerDocument || getCurrentDocument();
+ }
+ function createEvent(target, eventData, bubbles, cancelable) {
+ var doc = getTargetDocument(target);
+ var event = doc.createEvent('HTMLEvents');
+ var eventType;
+ if (typeof eventData === 'string') {
+ eventType = eventData;
+ } else {
+ eventType = eventData.type;
+ for (var prop in eventData) {
+ if (event[prop] === undefined) {
+ event[prop] = eventData[prop];
+ }
+ }
+ }
+ if (bubbles === undefined) {
+ bubbles = true;
+ }
+ event.initEvent(eventType, bubbles, cancelable);
+ return event;
+ }
+ function isDomEventTarget(obj) {
+ if (!(obj && obj.nodeName)) {
+ return obj === window;
+ }
+ var nodeType = obj.nodeType;
+ return nodeType === 1 || nodeType === 9 || nodeType === 11;
+ }
+ function addDomContext(context, args) {
+ if (isDomEventTarget(context)) {
+ args = Array.prototype.slice.call(args, 0);
+ args.unshift(context);
+ }
+ return args;
+ }
+ function removeDomContext(context, args) {
+ if (!isDomEventTarget(context)) {
+ args = Array.prototype.slice.call(args, 0);
+ context = args.shift();
+ }
+ return {
+ context: context,
+ args: args
+ };
+ }
+ var fixSyntheticEventsOnDisabled = false;
+ (function () {
+ if (!isBrowserWindow()) {
+ return;
+ }
+ var testEventName = 'fix_synthetic_events_on_disabled_test';
+ var input = document.createElement('input');
+ input.disabled = true;
+ var timer = setTimeout(function () {
+ fixSyntheticEventsOnDisabled = true;
+ }, 50);
+ var onTest = function onTest() {
+ clearTimeout(timer);
+ input.removeEventListener(testEventName, onTest);
+ };
+ input.addEventListener(testEventName, onTest);
+ try {
+ var event = document.create('HTMLEvents');
+ event.initEvent(testEventName, false);
+ input.dispatchEvent(event);
+ } catch (e) {
+ onTest();
+ fixSyntheticEventsOnDisabled = true;
+ }
+ }());
+ function isDispatchingOnDisabled(element, event) {
+ var eventType = event.type;
+ var isInsertedOrRemoved = eventType === 'inserted' || eventType === 'removed';
+ var isDisabled = !!element.disabled;
+ return isInsertedOrRemoved && isDisabled;
+ }
+ function forceEnabledForDispatch(element, event) {
+ return fixSyntheticEventsOnDisabled && isDispatchingOnDisabled(element, event);
+ }
+ module.exports = {
+ createEvent: createEvent,
+ addDomContext: addDomContext,
+ removeDomContext: removeDomContext,
+ isDomEventTarget: isDomEventTarget,
+ getTargetDocument: getTargetDocument,
+ forceEnabledForDispatch: forceEnabledForDispatch
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-dom-events@1.0.7#helpers/add-event-compat*/
+define('can-dom-events/helpers/add-event-compat', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-dom-events/helpers/util'
+], function (require, exports, module) {
+ 'use strict';
+ var util = require('can-dom-events/helpers/util');
+ var addDomContext = util.addDomContext;
+ var removeDomContext = util.removeDomContext;
+ function isDomEvents(obj) {
+ return !!(obj && obj.addEventListener && obj.removeEventListener && obj.dispatch);
+ }
+ function isNewEvents(obj) {
+ return typeof obj.addEvent === 'function';
+ }
+ module.exports = function addEventCompat(domEvents, customEvent, customEventType) {
+ if (!isDomEvents(domEvents)) {
+ throw new Error('addEventCompat() must be passed can-dom-events or can-util/dom/events/events');
+ }
+ customEventType = customEventType || customEvent.defaultEventType;
+ if (isNewEvents(domEvents)) {
+ return domEvents.addEvent(customEvent, customEventType);
+ }
+ var registry = domEvents._compatRegistry;
+ if (!registry) {
+ registry = domEvents._compatRegistry = {};
+ }
+ if (registry[customEventType]) {
+ return function noopRemoveOverride() {
+ };
+ }
+ registry[customEventType] = customEvent;
+ var newEvents = {
+ addEventListener: function () {
+ var data = removeDomContext(this, arguments);
+ return domEvents.addEventListener.apply(data.context, data.args);
+ },
+ removeEventListener: function () {
+ var data = removeDomContext(this, arguments);
+ return domEvents.removeEventListener.apply(data.context, data.args);
+ },
+ dispatch: function () {
+ var data = removeDomContext(this, arguments);
+ var eventData = data.args[0];
+ var eventArgs = typeof eventData === 'object' ? eventData.args : [];
+ data.args.splice(1, 0, eventArgs);
+ return domEvents.dispatch.apply(data.context, data.args);
+ }
+ };
+ var isOverriding = true;
+ var oldAddEventListener = domEvents.addEventListener;
+ var addEventListener = domEvents.addEventListener = function addEventListener(eventName) {
+ if (isOverriding && eventName === customEventType) {
+ var args = addDomContext(this, arguments);
+ customEvent.addEventListener.apply(newEvents, args);
+ }
+ return oldAddEventListener.apply(this, arguments);
+ };
+ var oldRemoveEventListener = domEvents.removeEventListener;
+ var removeEventListener = domEvents.removeEventListener = function removeEventListener(eventName) {
+ if (isOverriding && eventName === customEventType) {
+ var args = addDomContext(this, arguments);
+ customEvent.removeEventListener.apply(newEvents, args);
+ }
+ return oldRemoveEventListener.apply(this, arguments);
+ };
+ return function removeOverride() {
+ isOverriding = false;
+ registry[customEventType] = null;
+ if (domEvents.addEventListener === addEventListener) {
+ domEvents.addEventListener = oldAddEventListener;
+ }
+ if (domEvents.removeEventListener === removeEventListener) {
+ domEvents.removeEventListener = oldRemoveEventListener;
+ }
+ };
+ };
+});
+/*can-event-dom-enter@1.0.4#can-event-dom-enter*/
+define('can-event-dom-enter', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-dom-data-state',
+ 'can-cid'
+], function (require, exports, module) {
+ 'use strict';
+ var domData = require('can-dom-data-state');
+ var canCid = require('can-cid');
+ var baseEventType = 'keyup';
+ function isEnterEvent(event) {
+ var hasEnterKey = event.key === 'Enter';
+ var hasEnterCode = event.keyCode === 13;
+ return hasEnterKey || hasEnterCode;
+ }
+ function getHandlerKey(eventType, handler) {
+ return eventType + ':' + canCid(handler);
+ }
+ function associateHandler(target, eventType, handler, otherHandler) {
+ var key = getHandlerKey(eventType, handler);
+ domData.set.call(target, key, otherHandler);
+ }
+ function disassociateHandler(target, eventType, handler) {
+ var key = getHandlerKey(eventType, handler);
+ var otherHandler = domData.get.call(target, key);
+ if (otherHandler) {
+ domData.clean.call(target, key);
+ }
+ return otherHandler;
+ }
+ module.exports = {
+ defaultEventType: 'enter',
+ addEventListener: function (target, eventType, handler) {
+ var keyHandler = function (event) {
+ if (isEnterEvent(event)) {
+ return handler.apply(this, arguments);
+ }
+ };
+ associateHandler(target, eventType, handler, keyHandler);
+ this.addEventListener(target, baseEventType, keyHandler);
+ },
+ removeEventListener: function (target, eventType, handler) {
+ var keyHandler = disassociateHandler(target, eventType, handler);
+ if (keyHandler) {
+ this.removeEventListener(target, baseEventType, keyHandler);
+ }
+ }
+ };
+});
+/*can-event-dom-enter@1.0.4#compat*/
+define('can-event-dom-enter/compat', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-dom-events/helpers/add-event-compat',
+ 'can-event-dom-enter'
+], function (require, exports, module) {
+ var addEventCompat = require('can-dom-events/helpers/add-event-compat');
+ var radioChange = require('can-event-dom-enter');
+ module.exports = function (domEvents, eventType) {
+ return addEventCompat(domEvents, radioChange, eventType);
+ };
+});
+/*can-dom-events@1.0.7#helpers/make-event-registry*/
+define('can-dom-events/helpers/make-event-registry', function (require, exports, module) {
+ 'use strict';
+ function EventRegistry() {
+ this._registry = {};
+ }
+ module.exports = function makeEventRegistry() {
+ return new EventRegistry();
+ };
+ EventRegistry.prototype.has = function (eventType) {
+ return !!this._registry[eventType];
+ };
+ EventRegistry.prototype.get = function (eventType) {
+ return this._registry[eventType];
+ };
+ EventRegistry.prototype.add = function (event, eventType) {
+ if (!event) {
+ throw new Error('An EventDefinition must be provided');
+ }
+ if (typeof event.addEventListener !== 'function') {
+ throw new TypeError('EventDefinition addEventListener must be a function');
+ }
+ if (typeof event.removeEventListener !== 'function') {
+ throw new TypeError('EventDefinition removeEventListener must be a function');
+ }
+ eventType = eventType || event.defaultEventType;
+ if (typeof eventType !== 'string') {
+ throw new TypeError('Event type must be a string, not ' + eventType);
+ }
+ if (this.has(eventType)) {
+ throw new Error('Event "' + eventType + '" is already registered');
+ }
+ this._registry[eventType] = event;
+ var self = this;
+ return function remove() {
+ self._registry[eventType] = undefined;
+ };
+ };
+});
+/*can-dom-events@1.0.7#can-dom-events*/
+define('can-dom-events', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-namespace',
+ 'can-dom-events/helpers/util',
+ 'can-dom-events/helpers/make-event-registry'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var namespace = require('can-namespace');
+ var util = require('can-dom-events/helpers/util');
+ var makeEventRegistry = require('can-dom-events/helpers/make-event-registry');
+ var domEvents = {
+ _eventRegistry: makeEventRegistry(),
+ addEvent: function (event, eventType) {
+ return this._eventRegistry.add(event, eventType);
+ },
+ addEventListener: function (target, eventType) {
+ var hasCustomEvent = domEvents._eventRegistry.has(eventType);
+ if (hasCustomEvent) {
+ var event = domEvents._eventRegistry.get(eventType);
+ return event.addEventListener.apply(domEvents, arguments);
+ }
+ var eventArgs = Array.prototype.slice.call(arguments, 1);
+ return target.addEventListener.apply(target, eventArgs);
+ },
+ removeEventListener: function (target, eventType) {
+ var hasCustomEvent = domEvents._eventRegistry.has(eventType);
+ if (hasCustomEvent) {
+ var event = domEvents._eventRegistry.get(eventType);
+ return event.removeEventListener.apply(domEvents, arguments);
+ }
+ var eventArgs = Array.prototype.slice.call(arguments, 1);
+ return target.removeEventListener.apply(target, eventArgs);
+ },
+ dispatch: function (target, eventData, bubbles, cancelable) {
+ var event = util.createEvent(target, eventData, bubbles, cancelable);
+ var enableForDispatch = util.forceEnabledForDispatch(target, event);
+ if (enableForDispatch) {
+ target.disabled = false;
+ }
+ var ret = target.dispatchEvent(event);
+ if (enableForDispatch) {
+ target.disabled = true;
+ }
+ return ret;
+ }
+ };
+ module.exports = namespace.domEvents = domEvents;
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-event-dom-radiochange@1.0.5#can-event-dom-radiochange*/
+define('can-event-dom-radiochange', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-dom-data-state',
+ 'can-globals/document/document',
+ 'can-dom-events',
+ 'can-cid/map/map'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ 'use strict';
+ var domData = require('can-dom-data-state');
+ var getDocument = require('can-globals/document/document');
+ var domEvents = require('can-dom-events');
+ var CIDMap = require('can-cid/map/map');
+ function getRoot(el) {
+ return el.ownerDocument || getDocument().documentElement;
+ }
+ function getRegistryName(eventName) {
+ return 'can-event-radiochange:' + eventName + ':registry';
+ }
+ function getListenerName(eventName) {
+ return 'can-event-radiochange:' + eventName + ':listener';
+ }
+ function getRegistry(root, eventName) {
+ var name = getRegistryName(eventName);
+ var registry = domData.get.call(root, name);
+ if (!registry) {
+ registry = new CIDMap();
+ domData.set.call(root, name, registry);
+ }
+ return registry;
+ }
+ function findParentForm(el) {
+ while (el) {
+ if (el.nodeName === 'FORM') {
+ break;
+ }
+ el = el.parentNode;
+ }
+ return el;
+ }
+ function shouldReceiveEventFromRadio(source, dest) {
+ var name = source.getAttribute('name');
+ return name && name === dest.getAttribute('name') && findParentForm(source) === findParentForm(dest);
+ }
+ function isRadioInput(el) {
+ return el.nodeName === 'INPUT' && el.type === 'radio';
+ }
+ function dispatch(eventName, target) {
+ var root = getRoot(target);
+ var registry = getRegistry(root, eventName);
+ registry.forEach(function (el) {
+ if (shouldReceiveEventFromRadio(target, el)) {
+ domEvents.dispatch(el, eventName);
+ }
+ });
+ }
+ function attachRootListener(root, eventName, events) {
+ var listenerName = getListenerName(eventName);
+ var listener = domData.get.call(root, listenerName);
+ if (listener) {
+ return;
+ }
+ var newListener = function (event) {
+ var target = event.target;
+ if (isRadioInput(target)) {
+ dispatch(eventName, target);
+ }
+ };
+ events.addEventListener(root, 'change', newListener);
+ domData.set.call(root, listenerName, newListener);
+ }
+ function detachRootListener(root, eventName, events) {
+ var listenerName = getListenerName(eventName);
+ var listener = domData.get.call(root, listenerName);
+ if (!listener) {
+ return;
+ }
+ var registry = getRegistry(root, eventName);
+ if (registry.size > 0) {
+ return;
+ }
+ events.removeEventListener(root, 'change', listener);
+ domData.clean.call(root, listenerName);
+ }
+ function addListener(eventName, el, events) {
+ if (!isRadioInput(el)) {
+ throw new Error('Listeners for ' + eventName + ' must be radio inputs');
+ }
+ var root = getRoot(el);
+ getRegistry(root, eventName).set(el, el);
+ attachRootListener(root, eventName, events);
+ }
+ function removeListener(eventName, el, events) {
+ var root = getRoot(el);
+ getRegistry(root, eventName).delete(el);
+ detachRootListener(root, eventName, events);
+ }
+ module.exports = {
+ defaultEventType: 'radiochange',
+ addEventListener: function (target, eventName, handler) {
+ addListener(eventName, target, this);
+ target.addEventListener(eventName, handler);
+ },
+ removeEventListener: function (target, eventName, handler) {
+ removeListener(eventName, target, this);
+ target.removeEventListener(eventName, handler);
+ }
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-event-dom-radiochange@1.0.5#compat*/
+define('can-event-dom-radiochange/compat', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-dom-events/helpers/add-event-compat',
+ 'can-event-dom-radiochange'
+], function (require, exports, module) {
+ var addEventCompat = require('can-dom-events/helpers/add-event-compat');
+ var radioChange = require('can-event-dom-radiochange');
+ module.exports = function (domEvents, eventType) {
+ return addEventCompat(domEvents, radioChange, eventType);
+ };
+});
+/*can-stache-bindings@3.11.4#can-stache-bindings*/
+define('can-stache-bindings', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-stache/src/expression',
+ 'can-view-callbacks',
+ 'can-view-live',
+ 'can-view-scope',
+ 'can-view-model',
+ 'can-event',
+ 'can-compute',
+ 'can-stache-key',
+ 'can-observation',
+ 'can-simple-observable',
+ 'can-util/js/assign/assign',
+ 'can-util/js/make-array/make-array',
+ 'can-util/js/each/each',
+ 'can-util/js/string/string',
+ 'can-log/dev/dev',
+ 'can-types',
+ 'can-util/js/last/last',
+ 'can-globals/mutation-observer/mutation-observer',
+ 'can-util/dom/events/events',
+ 'can-util/dom/events/removed/removed',
+ 'can-util/dom/data/data',
+ 'can-util/dom/attr/attr',
+ 'can-log',
+ 'can-stache/helpers/core',
+ 'can-symbol',
+ 'can-reflect',
+ 'can-util/js/single-reference/single-reference',
+ 'can-attribute-encoder',
+ 'can-event-dom-enter/compat',
+ 'can-event-dom-radiochange/compat'
+], function (require, exports, module) {
+ (function (global, require, exports, module) {
+ var expression = require('can-stache/src/expression');
+ var viewCallbacks = require('can-view-callbacks');
+ var live = require('can-view-live');
+ var Scope = require('can-view-scope');
+ var canViewModel = require('can-view-model');
+ var canEvent = require('can-event');
+ var compute = require('can-compute');
+ var observeReader = require('can-stache-key');
+ var Observation = require('can-observation');
+ var observable = require('can-simple-observable');
+ var assign = require('can-util/js/assign/assign');
+ var makeArray = require('can-util/js/make-array/make-array');
+ var each = require('can-util/js/each/each');
+ var string = require('can-util/js/string/string');
+ var dev = require('can-log/dev/dev');
+ var types = require('can-types');
+ var last = require('can-util/js/last/last');
+ var getMutationObserver = require('can-globals/mutation-observer/mutation-observer');
+ var domEvents = require('can-util/dom/events/events');
+ require('can-util/dom/events/removed/removed');
+ var domData = require('can-util/dom/data/data');
+ var attr = require('can-util/dom/attr/attr');
+ var canLog = require('can-log');
+ var stacheHelperCore = require('can-stache/helpers/core');
+ var canSymbol = require('can-symbol');
+ var canReflect = require('can-reflect');
+ var singleReference = require('can-util/js/single-reference/single-reference');
+ var encoder = require('can-attribute-encoder');
+ var addEnterEvent = require('can-event-dom-enter/compat');
+ addEnterEvent(domEvents);
+ var addRadioChange = require('can-event-dom-radiochange/compat');
+ addRadioChange(domEvents);
+ var noop = function () {
+ };
+ var onMatchStr = 'on:', vmMatchStr = 'vm:', elMatchStr = 'el:', byMatchStr = ':by:', toMatchStr = ':to', fromMatchStr = ':from', bindMatchStr = ':bind', attributesEventStr = 'attributes', removedStr = 'removed', viewModelBindingStr = 'viewModel', attributeBindingStr = 'attribute', scopeBindingStr = 'scope', viewModelOrAttributeBindingStr = 'viewModelOrAttribute', getValueSymbol = 'can.getValue', setValueSymbol = 'can.setValue', onValueSymbol = 'can.onValue', offValueSymbol = 'can.offValue';
+ function isBindingsAttribute(attributeName) {
+ return attributeName.indexOf(toMatchStr) !== -1 || attributeName.indexOf(fromMatchStr) !== -1 || attributeName.indexOf(bindMatchStr) !== -1;
+ }
+ function setPriority(observable, priority) {
+ if (observable instanceof Observation) {
+ observable.compute._primaryDepth = priority;
+ } else if (observable.computeInstance) {
+ observable.computeInstance.setPrimaryDepth(priority);
+ } else if (observable.observation) {
+ observable.observation.compute._primaryDepth = priority;
+ }
+ }
+ var throwOnlyOneTypeOfBindingError = function () {
+ throw new Error('can-stache-bindings - you can not have contextual bindings ( this:from=\'value\' ) and key bindings ( prop:from=\'value\' ) on one element.');
+ };
+ var checkBindingState = function (bindingState, dataBinding) {
+ var isSettingOnViewModel = dataBinding.bindingInfo.parentToChild && dataBinding.bindingInfo.child === viewModelBindingStr;
+ if (isSettingOnViewModel) {
+ var bindingName = dataBinding.bindingInfo.childName;
+ var isSettingViewModel = isSettingOnViewModel && (bindingName === 'this' || bindingName === '.');
+ if (isSettingViewModel) {
+ if (bindingState.isSettingViewModel || bindingState.isSettingOnViewModel) {
+ throwOnlyOneTypeOfBindingError();
+ } else {
+ return {
+ isSettingViewModel: true,
+ initialViewModelData: undefined
+ };
+ }
+ } else {
+ if (bindingState.isSettingViewModel) {
+ throwOnlyOneTypeOfBindingError();
+ } else {
+ return {
+ isSettingOnViewModel: true,
+ initialViewModelData: bindingState.initialViewModelData
+ };
+ }
+ }
+ } else {
+ return bindingState;
+ }
+ };
+ var behaviors = {
+ viewModel: function (el, tagData, makeViewModel, initialViewModelData, staticDataBindingsOnly) {
+ var bindingsSemaphore = {}, viewModel, onCompleteBindings = [], onTeardowns = {}, bindingInfos = {}, attributeViewModelBindings = assign({}, initialViewModelData), bindingsState = {
+ isSettingOnViewModel: false,
+ isSettingViewModel: false,
+ initialViewModelData: initialViewModelData || {}
+ }, hasDataBinding = false;
+ each(makeArray(el.attributes), function (node) {
+ var dataBinding = makeDataBinding(node, el, {
+ templateType: tagData.templateType,
+ scope: tagData.scope,
+ semaphore: bindingsSemaphore,
+ getViewModel: function () {
+ return viewModel;
+ },
+ attributeViewModelBindings: attributeViewModelBindings,
+ alreadyUpdatedChild: true,
+ nodeList: tagData.parentNodeList,
+ favorViewModel: true
+ });
+ if (dataBinding) {
+ bindingsState = checkBindingState(bindingsState, dataBinding);
+ hasDataBinding = true;
+ if (dataBinding.onCompleteBinding) {
+ if (dataBinding.bindingInfo.parentToChild && dataBinding.value !== undefined) {
+ if (bindingsState.isSettingViewModel) {
+ bindingsState.initialViewModelData = dataBinding.value;
+ } else {
+ bindingsState.initialViewModelData[cleanVMName(dataBinding.bindingInfo.childName)] = dataBinding.value;
+ }
+ }
+ onCompleteBindings.push(dataBinding.onCompleteBinding);
+ }
+ onTeardowns[node.name] = dataBinding.onTeardown;
+ }
+ });
+ if (staticDataBindingsOnly && !hasDataBinding) {
+ return;
+ }
+ viewModel = makeViewModel(bindingsState.initialViewModelData, hasDataBinding);
+ for (var i = 0, len = onCompleteBindings.length; i < len; i++) {
+ onCompleteBindings[i]();
+ }
+ var attributeListener;
+ if (!bindingsState.isSettingViewModel) {
+ attributeListener = function (ev) {
+ var attrName = ev.attributeName, value = el.getAttribute(attrName);
+ if (onTeardowns[attrName]) {
+ onTeardowns[attrName]();
+ }
+ var parentBindingWasAttribute = bindingInfos[attrName] && bindingInfos[attrName].parent === attributeBindingStr;
+ if (value !== null || parentBindingWasAttribute) {
+ var dataBinding = makeDataBinding({
+ name: attrName,
+ value: value
+ }, el, {
+ templateType: tagData.templateType,
+ scope: tagData.scope,
+ semaphore: {},
+ getViewModel: function () {
+ return viewModel;
+ },
+ attributeViewModelBindings: attributeViewModelBindings,
+ initializeValues: true,
+ nodeList: tagData.parentNodeList
+ });
+ if (dataBinding) {
+ if (dataBinding.onCompleteBinding) {
+ dataBinding.onCompleteBinding();
+ }
+ bindingInfos[attrName] = dataBinding.bindingInfo;
+ onTeardowns[attrName] = dataBinding.onTeardown;
+ }
+ }
+ };
+ domEvents.addEventListener.call(el, attributesEventStr, attributeListener);
+ }
+ return function () {
+ domEvents.removeEventListener.call(el, attributesEventStr, attributeListener);
+ for (var attrName in onTeardowns) {
+ onTeardowns[attrName]();
+ }
+ };
+ },
+ data: function (el, attrData) {
+ if (domData.get.call(el, 'preventDataBindings')) {
+ return;
+ }
+ var viewModel, getViewModel = function () {
+ return viewModel || (viewModel = canViewModel(el));
+ }, semaphore = {}, teardown;
+ var legacyBindings = bindingsRegExp.exec(attrData.attributeName);
+ var twoWay = legacyBindings && legacyBindings[1];
+ var dataBinding = makeDataBinding({
+ name: attrData.attributeName,
+ value: el.getAttribute(attrData.attributeName),
+ nodeList: attrData.nodeList
+ }, el, {
+ templateType: attrData.templateType,
+ scope: attrData.scope,
+ semaphore: semaphore,
+ getViewModel: getViewModel,
+ syncChildWithParent: twoWay
+ });
+ if (dataBinding.onCompleteBinding) {
+ dataBinding.onCompleteBinding();
+ }
+ var attributeListener = function (ev) {
+ var attrName = ev.attributeName, value = el.getAttribute(attrName);
+ if (attrName === attrData.attributeName) {
+ if (teardown) {
+ teardown();
+ }
+ if (value !== null) {
+ var dataBinding = makeDataBinding({
+ name: attrName,
+ value: value
+ }, el, {
+ templateType: attrData.templateType,
+ scope: attrData.scope,
+ semaphore: semaphore,
+ getViewModel: getViewModel,
+ initializeValues: true,
+ nodeList: attrData.nodeList,
+ syncChildWithParent: twoWay
+ });
+ if (dataBinding) {
+ if (dataBinding.onCompleteBinding) {
+ dataBinding.onCompleteBinding();
+ }
+ teardown = dataBinding.onTeardown;
+ }
+ }
+ }
+ };
+ domEvents.addEventListener.call(el, attributesEventStr, attributeListener);
+ teardown = dataBinding.onTeardown;
+ canEvent.one.call(el, removedStr, function () {
+ teardown();
+ domEvents.removeEventListener.call(el, attributesEventStr, attributeListener);
+ });
+ },
+ reference: function (el, attrData) {
+ if (el.getAttribute(attrData.attributeName)) {
+ canLog.warn('*reference attributes can only export the view model.');
+ }
+ var name = string.camelize(attrData.attributeName.substr(1).toLowerCase());
+ var viewModel = canViewModel(el);
+ attrData.scope.set('scope.vars.' + name, viewModel);
+ },
+ event: function (el, data) {
+ var attributeName = encoder.decode(data.attributeName), event, bindingContext;
+ if (attributeName.indexOf(toMatchStr + ':') !== -1 || attributeName.indexOf(fromMatchStr + ':') !== -1 || attributeName.indexOf(bindMatchStr + ':') !== -1) {
+ return this.data(el, data);
+ }
+ if (startsWith.call(attributeName, 'can-')) {
+ event = attributeName.substr('can-'.length);
+ bindingContext = el;
+ } else if (startsWith.call(attributeName, onMatchStr)) {
+ event = attributeName.substr(onMatchStr.length);
+ var viewModel = domData.get.call(el, viewModelBindingStr);
+ var byParent = data.scope;
+ if (startsWith.call(event, elMatchStr)) {
+ event = event.substr(elMatchStr.length);
+ bindingContext = el;
+ } else {
+ if (startsWith.call(event, vmMatchStr)) {
+ event = event.substr(vmMatchStr.length);
+ bindingContext = viewModel;
+ byParent = viewModel;
+ } else {
+ bindingContext = viewModel || el;
+ }
+ var byIndex = event.indexOf(byMatchStr);
+ if (byIndex >= 0) {
+ bindingContext = byParent.get(decodeAttrName(event.substr(byIndex + byMatchStr.length)));
+ event = event.substr(0, byIndex);
+ }
+ }
+ } else {
+ event = removeBrackets(attributeName, '(', ')');
+ dev.warn('can-stache-bindings: the event binding format (' + event + ') is deprecated. Use on:' + string.camelize(event[0] === '$' ? event.slice(1) : event.split(' ').reverse().filter(function (s) {
+ return s;
+ }).join(':by:')) + ' instead');
+ if (event.charAt(0) === '$') {
+ event = event.substr(1);
+ bindingContext = el;
+ } else {
+ if (event.indexOf(' ') >= 0) {
+ var eventSplit = event.split(' ');
+ bindingContext = data.scope.get(decodeAttrName(eventSplit[0]));
+ event = eventSplit[1];
+ } else {
+ bindingContext = canViewModel(el);
+ }
+ }
+ }
+ event = decodeAttrName(event);
+ var handler = function (ev) {
+ var attrVal = el.getAttribute(encoder.encode(attributeName));
+ if (!attrVal) {
+ return;
+ }
+ var viewModel = canViewModel(el);
+ var expr = expression.parse(removeBrackets(attrVal), {
+ lookupRule: function () {
+ return expression.Lookup;
+ },
+ methodRule: 'call'
+ });
+ if (!(expr instanceof expression.Call) && !(expr instanceof expression.Helper)) {
+ var defaultArgs = [
+ data.scope._context,
+ el
+ ].concat(makeArray(arguments)).map(function (data) {
+ return new expression.Arg(new expression.Literal(data));
+ });
+ expr = new expression.Call(expr, defaultArgs, {});
+ }
+ var specialValues = {
+ element: el,
+ event: ev,
+ viewModel: viewModel,
+ arguments: arguments
+ };
+ var legacySpecialValues = {
+ '@element': el,
+ '@event': ev,
+ '@viewModel': viewModel,
+ '@scope': data.scope,
+ '@context': data.scope._context,
+ '%element': this,
+ '$element': types.wrapElement(el),
+ '%event': ev,
+ '%viewModel': viewModel,
+ '%scope': data.scope,
+ '%context': data.scope._context,
+ '%arguments': arguments
+ };
+ var localScope = data.scope.add(legacySpecialValues, { notContext: true }).add(specialValues, { special: true });
+ var scopeData = localScope.read(expr.methodExpr.key, { isArgument: true }), args, stacheHelper, stacheHelperResult;
+ if (!scopeData.value) {
+ var name = observeReader.reads(expr.methodExpr.key).map(function (part) {
+ return part.key;
+ }).join('.');
+ stacheHelper = stacheHelperCore.getHelper(name);
+ if (stacheHelper) {
+ args = expr.args(localScope, null)();
+ stacheHelperResult = stacheHelper.fn.apply(localScope.peek('.'), args);
+ if (typeof stacheHelperResult === 'function') {
+ stacheHelperResult(el);
+ }
+ return stacheHelperResult;
+ }
+ return null;
+ }
+ args = expr.args(localScope, null)();
+ return scopeData.value.apply(scopeData.parent, args);
+ };
+ var attributesHandler = function (ev) {
+ var isEventAttribute = ev.attributeName === attributeName;
+ var isRemoved = !this.getAttribute(attributeName);
+ var isEventAttributeRemoved = isEventAttribute && isRemoved;
+ if (isEventAttributeRemoved) {
+ unbindEvent();
+ }
+ };
+ var removedHandler = function (ev) {
+ unbindEvent();
+ };
+ var unbindEvent = function () {
+ canEvent.off.call(bindingContext, event, handler);
+ canEvent.off.call(el, attributesEventStr, attributesHandler);
+ canEvent.off.call(el, removedStr, removedHandler);
+ };
+ canEvent.on.call(bindingContext, event, handler);
+ canEvent.on.call(el, attributesEventStr, attributesHandler);
+ canEvent.on.call(el, removedStr, removedHandler);
+ },
+ value: function (el, data) {
+ var propName = '$value', attrValue = removeBrackets(el.getAttribute('can-value')).trim(), nodeName = el.nodeName.toLowerCase(), elType = nodeName === 'input' && (el.type || el.getAttribute('type')), getterSetter;
+ if (nodeName === 'input' && (elType === 'checkbox' || elType === 'radio')) {
+ var property = getObservableFrom.scope(el, data.scope, attrValue, {}, true);
+ if (el.type === 'checkbox') {
+ var trueValue = attr.has(el, 'can-true-value') ? el.getAttribute('can-true-value') : true, falseValue = attr.has(el, 'can-false-value') ? el.getAttribute('can-false-value') : false;
+ getterSetter = compute(function (newValue) {
+ var isSet = arguments.length !== 0;
+ if (property && property[canSymbol.for(getValueSymbol)]) {
+ if (isSet) {
+ canReflect.setValue(property, newValue ? trueValue : falseValue);
+ } else {
+ return canReflect.getValue(property) == trueValue;
+ }
+ } else {
+ if (isSet) {
+ } else {
+ return property == trueValue;
+ }
+ }
+ });
+ } else if (elType === 'radio') {
+ getterSetter = compute(function (newValue) {
+ var isSet = arguments.length !== 0 && newValue;
+ if (property && property[canSymbol.for(getValueSymbol)]) {
+ if (isSet) {
+ canReflect.setValue(property, el.value);
+ } else {
+ return canReflect.getValue(property) == el.value;
+ }
+ } else {
+ if (isSet) {
+ } else {
+ return property == el.value;
+ }
+ }
+ });
+ }
+ propName = '$checked';
+ attrValue = 'getterSetter';
+ data.scope = new Scope({ getterSetter: getterSetter });
+ } else if (isContentEditable(el)) {
+ propName = '$innerHTML';
+ }
+ var dataBinding = makeDataBinding({
+ name: '{(' + propName + ')}',
+ value: attrValue
+ }, el, {
+ templateType: data.templateType,
+ scope: data.scope,
+ semaphore: {},
+ initializeValues: true,
+ legacyBindings: true
+ });
+ canEvent.one.call(el, removedStr, function () {
+ dataBinding.onTeardown();
+ });
+ }
+ };
+ viewCallbacks.attr(/^(:lb:)[(:c:)\w-]+(:rb:)$/, behaviors.data);
+ viewCallbacks.attr(/[\w\.:]+:to$/, behaviors.data);
+ viewCallbacks.attr(/[\w\.:]+:from$/, behaviors.data);
+ viewCallbacks.attr(/[\w\.:]+:bind$/, behaviors.data);
+ viewCallbacks.attr(/[\w\.:]+:to:on:[\w\.:]+/, behaviors.data);
+ viewCallbacks.attr(/[\w\.:]+:from:on:[\w\.:]+/, behaviors.data);
+ viewCallbacks.attr(/[\w\.:]+:bind:on:[\w\.:]+/, behaviors.data);
+ viewCallbacks.attr(/\*[\w\.\-_]+/, behaviors.reference);
+ viewCallbacks.attr(/on:[\w\.:]+/, behaviors.event);
+ viewCallbacks.attr(/^(:lp:)[(:d:)?\w\.\\]+(:rp:)$/, behaviors.event);
+ viewCallbacks.attr(/can-[\w\.]+/, behaviors.event);
+ viewCallbacks.attr('can-value', behaviors.value);
+ var getObservableFrom = {
+ viewModelOrAttribute: function (el, scope, vmNameOrProp, bindingData, mustBeSettable, stickyCompute, event) {
+ var viewModel = domData.get.call(el, viewModelBindingStr);
+ if (viewModel) {
+ return this.viewModel.apply(this, arguments);
+ } else {
+ return this.attribute.apply(this, arguments);
+ }
+ },
+ scope: function (el, scope, scopeProp, bindingData, mustBeSettable, stickyCompute) {
+ if (!scopeProp) {
+ return observable();
+ } else {
+ if (mustBeSettable) {
+ var parentExpression = expression.parse(scopeProp, { baseMethodType: 'Call' });
+ return parentExpression.value(scope, new Scope.Options({}));
+ } else {
+ var observation = new Observation(function () {
+ });
+ observation[canSymbol.for(setValueSymbol)] = function (newVal) {
+ scope.set(cleanVMName(scopeProp), newVal);
+ };
+ return observation;
+ }
+ }
+ },
+ viewModel: function (el, scope, vmName, bindingData, mustBeSettable, stickyCompute) {
+ var setName = cleanVMName(vmName);
+ var isBoundToContext = vmName === '.' || vmName === 'this';
+ var keysToRead = isBoundToContext ? [] : observeReader.reads(vmName);
+ var observation = new Observation(function () {
+ var viewModel = bindingData.getViewModel();
+ return observeReader.read(viewModel, keysToRead, {}).value;
+ });
+ observation[canSymbol.for(setValueSymbol)] = function (newVal) {
+ var viewModel = bindingData.getViewModel();
+ if (arguments.length) {
+ if (stickyCompute) {
+ var oldValue = canReflect.getKeyValue(viewModel, setName);
+ if (canReflect.isObservableLike(oldValue)) {
+ canReflect.setValue(oldValue, newVal);
+ } else {
+ canReflect.setKeyValue(viewModel, setName, observable(canReflect.getValue(stickyCompute)));
+ }
+ } else {
+ if (isBoundToContext) {
+ canReflect.setValue(viewModel, newVal);
+ } else {
+ canReflect.setKeyValue(viewModel, setName, newVal);
+ }
+ }
+ }
+ };
+ return observation;
+ },
+ attribute: function (el, scope, prop, bindingData, mustBeSettable, stickyCompute, event) {
+ if (!event) {
+ event = 'change';
+ var isRadioInput = el.nodeName === 'INPUT' && el.type === 'radio';
+ var isValidProp = prop === 'checked' && !bindingData.legacyBindings;
+ if (isRadioInput && isValidProp) {
+ event = 'radiochange';
+ }
+ var isSpecialProp = attr.special[prop] && attr.special[prop].addEventListener;
+ if (isSpecialProp) {
+ event = prop;
+ }
+ }
+ var hasChildren = el.nodeName.toLowerCase() === 'select', isMultiselectValue = prop === 'value' && hasChildren && el.multiple, set = function (newVal) {
+ if (bindingData.legacyBindings && hasChildren && 'selectedIndex' in el && prop === 'value') {
+ attr.setAttrOrProp(el, prop, newVal == null ? '' : newVal);
+ } else {
+ attr.setAttrOrProp(el, prop, newVal);
+ }
+ return newVal;
+ }, get = function () {
+ return attr.get(el, prop);
+ };
+ if (isMultiselectValue) {
+ prop = 'values';
+ }
+ var observation = new Observation(get);
+ observation[canSymbol.for(setValueSymbol)] = set;
+ observation[canSymbol.for(getValueSymbol)] = get;
+ observation[canSymbol.for(onValueSymbol)] = function (updater) {
+ var translationHandler = function () {
+ updater(get());
+ };
+ singleReference.set(updater, this, translationHandler);
+ if (event === 'radiochange') {
+ canEvent.on.call(el, 'change', translationHandler);
+ }
+ canEvent.on.call(el, event, translationHandler);
+ };
+ observation[canSymbol.for(offValueSymbol)] = function (updater) {
+ var translationHandler = singleReference.getAndDelete(updater, this);
+ if (event === 'radiochange') {
+ canEvent.off.call(el, 'change', translationHandler);
+ }
+ canEvent.off.call(el, event, translationHandler);
+ };
+ return observation;
+ }
+ };
+ var bind = {
+ childToParent: function (el, parentObservable, childObservable, bindingsSemaphore, attrName, syncChild) {
+ var updateParent = function (newVal) {
+ if (!bindingsSemaphore[attrName]) {
+ if (parentObservable && parentObservable[canSymbol.for(getValueSymbol)]) {
+ if (canReflect.getValue(parentObservable) !== newVal) {
+ canReflect.setValue(parentObservable, newVal);
+ }
+ if (syncChild) {
+ if (canReflect.getValue(parentObservable) !== canReflect.getValue(childObservable)) {
+ bindingsSemaphore[attrName] = (bindingsSemaphore[attrName] || 0) + 1;
+ canReflect.setValue(childObservable, canReflect.getValue(parentObservable));
+ Observation.afterUpdateAndNotify(function () {
+ --bindingsSemaphore[attrName];
+ });
+ }
+ }
+ } else if (canReflect.isMapLike(parentObservable)) {
+ var attrValue = el.getAttribute(attrName);
+ dev.warn('can-stache-bindings: Merging ' + attrName + ' into ' + attrValue + ' because its parent is non-observable');
+ canReflect.eachKey(parentObservable, function (prop) {
+ canReflect.deleteKeyValue(parentObservable, prop);
+ });
+ canReflect.setValue(parentObservable, newVal && newVal.serialize ? newVal.serialize() : newVal, true);
+ }
+ }
+ };
+ if (childObservable && childObservable[canSymbol.for(getValueSymbol)]) {
+ canReflect.onValue(childObservable, updateParent);
+ }
+ return updateParent;
+ },
+ parentToChild: function (el, parentObservable, childUpdate, bindingsSemaphore, attrName) {
+ var updateChild = function (newValue) {
+ bindingsSemaphore[attrName] = (bindingsSemaphore[attrName] || 0) + 1;
+ canReflect.setValue(childUpdate, newValue);
+ Observation.afterUpdateAndNotify(function () {
+ --bindingsSemaphore[attrName];
+ });
+ };
+ if (parentObservable && parentObservable[canSymbol.for(getValueSymbol)]) {
+ canReflect.onValue(parentObservable, updateChild);
+ }
+ return updateChild;
+ }
+ };
+ var startsWith = String.prototype.startsWith || function (text) {
+ return this.indexOf(text) === 0;
+ };
+ function getEventName(result) {
+ if (result.special.on !== undefined) {
+ return result.tokens[result.special.on + 1];
+ }
+ }
+ var bindingRules = {
+ to: {
+ childToParent: true,
+ parentToChild: false,
+ syncChildWithParent: false
+ },
+ from: {
+ childToParent: false,
+ parentToChild: true,
+ syncChildWithParent: false
+ },
+ bind: {
+ childToParent: true,
+ parentToChild: true,
+ syncChildWithParent: true
+ }
+ };
+ var bindingNames = [];
+ var special = {
+ vm: true,
+ on: true
+ };
+ each(bindingRules, function (value, key) {
+ bindingNames.push(key);
+ special[key] = true;
+ });
+ function tokenize(source) {
+ var splitByColon = source.split(':');
+ var result = {
+ tokens: [],
+ special: {}
+ };
+ splitByColon.forEach(function (token) {
+ if (special[token]) {
+ result.special[token] = result.tokens.push(token) - 1;
+ } else {
+ result.tokens.push(token);
+ }
+ });
+ return result;
+ }
+ var bindingsRegExp = /\{(\()?(\^)?([^\}\)]+)\)?\}/, ignoreAttributesRegExp = /^(data-view-id|class|name|id|\[[\w\.-]+\]|#[\w\.-])$/i, DOUBLE_CURLY_BRACE_REGEX = /\{\{/g, encodedSpacesRegExp = /\\s/g, encodedForwardSlashRegExp = /\\f/g;
+ var getChildBindingStr = function (tokens, favorViewModel) {
+ if (tokens.indexOf('vm') >= 0) {
+ return viewModelBindingStr;
+ } else if (tokens.indexOf('el') >= 0) {
+ return attributeBindingStr;
+ } else {
+ return favorViewModel ? viewModelBindingStr : viewModelOrAttributeBindingStr;
+ }
+ };
+ var getBindingInfo = function (node, attributeViewModelBindings, templateType, tagName, favorViewModel) {
+ var bindingInfo, attributeName = encoder.decode(node.name), attributeValue = node.value || '', childName;
+ var result = tokenize(attributeName), dataBindingName, specialIndex;
+ bindingNames.forEach(function (name) {
+ if (result.special[name] !== undefined && result.special[name] > 0) {
+ dataBindingName = name;
+ specialIndex = result.special[name];
+ return false;
+ }
+ });
+ if (dataBindingName) {
+ var childEventName = getEventName(result);
+ var initializeValues = childEventName ? false : true;
+ return assign({
+ parent: scopeBindingStr,
+ child: getChildBindingStr(result.tokens, favorViewModel),
+ childName: result.tokens[specialIndex - 1],
+ childEvent: childEventName,
+ bindingAttributeName: attributeName,
+ parentName: attributeValue,
+ initializeValues: initializeValues
+ }, bindingRules[dataBindingName]);
+ }
+ var matches = attributeName.match(bindingsRegExp);
+ if (!matches) {
+ var ignoreAttribute = ignoreAttributesRegExp.test(attributeName);
+ var vmName = string.camelize(attributeName);
+ if (ignoreAttribute || viewCallbacks.attr(encoder.encode(attributeName))) {
+ return;
+ }
+ var syntaxRight = attributeValue[0] === '{' && last(attributeValue) === '}';
+ var isAttributeToChild = templateType === 'legacy' ? attributeViewModelBindings[vmName] : !syntaxRight;
+ var scopeName = syntaxRight ? attributeValue.substr(1, attributeValue.length - 2) : attributeValue;
+ if (isAttributeToChild) {
+ return {
+ bindingAttributeName: attributeName,
+ parent: attributeBindingStr,
+ parentName: attributeName,
+ child: viewModelBindingStr,
+ childName: vmName,
+ parentToChild: true,
+ childToParent: true,
+ syncChildWithParent: true
+ };
+ } else {
+ return {
+ bindingAttributeName: attributeName,
+ parent: scopeBindingStr,
+ parentName: scopeName,
+ child: viewModelBindingStr,
+ childName: vmName,
+ parentToChild: true,
+ childToParent: true,
+ syncChildWithParent: true
+ };
+ }
+ }
+ var twoWay = !!matches[1], childToParent = twoWay || !!matches[2], parentToChild = twoWay || !childToParent;
+ childName = matches[3];
+ var newLookup = {
+ '^': ':to',
+ '(': ':bind'
+ };
+ dev.warn('can-stache-bindings: the data binding format ' + attributeName + ' is deprecated. Use ' + string.camelize(matches[3][0] === '$' ? matches[3].slice(1) : matches[3]) + (newLookup[attributeName.charAt(1)] || ':from') + ' instead');
+ var isDOM = childName.charAt(0) === '$';
+ if (isDOM) {
+ bindingInfo = {
+ parent: scopeBindingStr,
+ child: attributeBindingStr,
+ childToParent: childToParent,
+ parentToChild: parentToChild,
+ bindingAttributeName: attributeName,
+ childName: childName.substr(1),
+ parentName: attributeValue,
+ initializeValues: true,
+ syncChildWithParent: twoWay
+ };
+ if (tagName === 'select') {
+ bindingInfo.stickyParentToChild = true;
+ }
+ return bindingInfo;
+ } else {
+ bindingInfo = {
+ parent: scopeBindingStr,
+ child: viewModelBindingStr,
+ childToParent: childToParent,
+ parentToChild: parentToChild,
+ bindingAttributeName: attributeName,
+ childName: decodeAttrName(string.camelize(childName)),
+ parentName: attributeValue,
+ initializeValues: true,
+ syncChildWithParent: twoWay
+ };
+ if (attributeValue.trim().charAt(0) === '~') {
+ bindingInfo.stickyParentToChild = true;
+ }
+ return bindingInfo;
+ }
+ };
+ var decodeAttrName = function (name) {
+ return name.replace(encodedSpacesRegExp, ' ').replace(encodedForwardSlashRegExp, '/');
+ };
+ var makeDataBinding = function (node, el, bindingData) {
+ var bindingInfo = getBindingInfo(node, bindingData.attributeViewModelBindings, bindingData.templateType, el.nodeName.toLowerCase(), bindingData.favorViewModel);
+ if (!bindingInfo) {
+ return;
+ }
+ bindingInfo.alreadyUpdatedChild = bindingData.alreadyUpdatedChild;
+ if (bindingData.initializeValues) {
+ bindingInfo.initializeValues = true;
+ }
+ var parentObservable = getObservableFrom[bindingInfo.parent](el, bindingData.scope, bindingInfo.parentName, bindingData, bindingInfo.parentToChild), childObservable = getObservableFrom[bindingInfo.child](el, bindingData.scope, bindingInfo.childName, bindingData, bindingInfo.childToParent, bindingInfo.stickyParentToChild && parentObservable, bindingInfo.childEvent), updateParent, updateChild;
+ if (bindingData.nodeList) {
+ if (parentObservable) {
+ setPriority(parentObservable, bindingData.nodeList.nesting + 1);
+ }
+ if (childObservable) {
+ setPriority(childObservable, bindingData.nodeList.nesting + 1);
+ }
+ }
+ if (bindingInfo.parentToChild) {
+ updateChild = bind.parentToChild(el, parentObservable, childObservable, bindingData.semaphore, bindingInfo.bindingAttributeName);
+ }
+ var completeBinding = function () {
+ if (bindingInfo.childToParent) {
+ updateParent = bind.childToParent(el, parentObservable, childObservable, bindingData.semaphore, bindingInfo.bindingAttributeName, bindingInfo.syncChildWithParent);
+ } else if (bindingInfo.stickyParentToChild && childObservable[canSymbol.for(onValueSymbol)]) {
+ canReflect.onValue(childObservable, noop);
+ }
+ if (bindingInfo.initializeValues) {
+ initializeValues(bindingInfo, childObservable, parentObservable, updateChild, updateParent);
+ }
+ };
+ var onTeardown = function () {
+ unbindUpdate(parentObservable, updateChild);
+ unbindUpdate(childObservable, updateParent);
+ unbindUpdate(childObservable, noop);
+ };
+ if (bindingInfo.child === viewModelBindingStr) {
+ return {
+ value: bindingInfo.stickyParentToChild ? observable(getValue(parentObservable)) : getValue(parentObservable),
+ onCompleteBinding: completeBinding,
+ bindingInfo: bindingInfo,
+ onTeardown: onTeardown
+ };
+ } else {
+ completeBinding();
+ return {
+ bindingInfo: bindingInfo,
+ onTeardown: onTeardown
+ };
+ }
+ };
+ var initializeValues = function (bindingInfo, childObservable, parentObservable, updateChild, updateParent) {
+ var doUpdateParent = false;
+ if (bindingInfo.parentToChild && !bindingInfo.childToParent) {
+ } else if (!bindingInfo.parentToChild && bindingInfo.childToParent) {
+ doUpdateParent = true;
+ } else if (getValue(childObservable) === undefined) {
+ } else if (getValue(parentObservable) === undefined) {
+ doUpdateParent = true;
+ }
+ if (doUpdateParent) {
+ updateParent(getValue(childObservable));
+ } else {
+ if (!bindingInfo.alreadyUpdatedChild) {
+ updateChild(getValue(parentObservable));
+ }
+ }
+ };
+ if (!getMutationObserver()) {
+ var updateSelectValue = function (el) {
+ var bindingCallback = domData.get.call(el, 'canBindingCallback');
+ if (bindingCallback) {
+ bindingCallback.onMutation(el);
+ }
+ };
+ live.registerChildMutationCallback('select', updateSelectValue);
+ live.registerChildMutationCallback('optgroup', function (el) {
+ updateSelectValue(el.parentNode);
+ });
+ }
+ var isContentEditable = function () {
+ var values = {
+ '': true,
+ 'true': true,
+ 'false': false
+ };
+ var editable = function (el) {
+ if (!el || !el.getAttribute) {
+ return;
+ }
+ var attr = el.getAttribute('contenteditable');
+ return values[attr];
+ };
+ return function (el) {
+ var val = editable(el);
+ if (typeof val === 'boolean') {
+ return val;
+ } else {
+ return !!editable(el.parentNode);
+ }
+ };
+ }(), removeBrackets = function (value, open, close) {
+ open = open || '{';
+ close = close || '}';
+ if (value[0] === open && value[value.length - 1] === close) {
+ return value.substr(1, value.length - 2);
+ }
+ return value;
+ }, getValue = function (value) {
+ return value && value[canSymbol.for(getValueSymbol)] ? canReflect.getValue(value) : value;
+ }, unbindUpdate = function (observable, updater) {
+ if (observable && observable[canSymbol.for(getValueSymbol)] && typeof updater === 'function') {
+ canReflect.offValue(observable, updater);
+ }
+ }, cleanVMName = function (name) {
+ return name.replace(/@/g, '');
+ };
+ module.exports = {
+ behaviors: behaviors,
+ getBindingInfo: getBindingInfo
+ };
+ }(function () {
+ return this;
+ }(), require, exports, module));
+});
+/*can-component@3.3.6#can-component*/
+define('can-component', [
+ 'require',
+ 'exports',
+ 'module',
+ 'can-component/control/control',
+ 'can-namespace',
+ 'can-construct',
+ 'can-stache-bindings',
+ 'can-view-scope',
+ 'can-view-callbacks',
+ 'can-view-nodelist',
+ 'can-compute',
+ 'can-util/dom/data/data',
+ 'can-util/dom/mutate/mutate',
+ 'can-util/dom/child-nodes/child-nodes',
+ 'can-util/dom/dispatch/dispatch',
+ 'can-types',
+ 'can-util/js/string/string',
+ 'can-reflect',
+ 'can-util/js/each/each',
+ 'can-util/js/assign/assign',
+ 'can-util/js/is-function/is-function',
+ 'can-util/js/log/log',
+ 'can-util/js/dev/dev',
+ 'can-util/js/make-array/make-array',
+ 'can-util/js/is-empty-object/is-empty-object',
+ 'can-util/dom/events/inserted/inserted',
+ 'can-util/dom/events/removed/removed',
+ 'can-view-model'
+], function (require, exports, module) {
+ var ComponentControl = require('can-component/control/control');
+ var namespace = require('can-namespace');
+ var Construct = require('can-construct');
+ var stacheBindings = require('can-stache-bindings');
+ var Scope = require('can-view-scope');
+ var viewCallbacks = require('can-view-callbacks');
+ var nodeLists = require('can-view-nodelist');
+ var compute = require('can-compute');
+ var domData = require('can-util/dom/data/data');
+ var domMutate = require('can-util/dom/mutate/mutate');
+ var getChildNodes = require('can-util/dom/child-nodes/child-nodes');
+ var domDispatch = require('can-util/dom/dispatch/dispatch');
+ var types = require('can-types');
+ var string = require('can-util/js/string/string');
+ var canReflect = require('can-reflect');
+ var canEach = require('can-util/js/each/each');
+ var assign = require('can-util/js/assign/assign');
+ var isFunction = require('can-util/js/is-function/is-function');
+ var canLog = require('can-util/js/log/log');
+ var canDev = require('can-util/js/dev/dev');
+ var makeArray = require('can-util/js/make-array/make-array');
+ var isEmptyObject = require('can-util/js/is-empty-object/is-empty-object');
+ require('can-util/dom/events/inserted/inserted');
+ require('can-util/dom/events/removed/removed');
+ require('can-view-model');
+ function addContext(el, tagData, insertionElementTagData) {
+ var vm;
+ domData.set.call(el, 'preventDataBindings', true);
+ var teardown = stacheBindings.behaviors.viewModel(el, insertionElementTagData, function (initialData) {
+ return vm = compute(initialData);
+ }, undefined, true);
+ if (!teardown) {
+ return tagData;
+ } else {
+ return assign(assign({}, tagData), {
+ teardown: teardown,
+ scope: tagData.scope.add(vm)
+ });
+ }
+ }
+ function makeInsertionTagCallback(tagName, componentTagData, shadowTagData, leakScope, getPrimaryTemplate) {
+ var options = shadowTagData.options._context;
+ return function hookupFunction(el, insertionElementTagData) {
+ var template = getPrimaryTemplate(el) || insertionElementTagData.subtemplate, renderingLightContent = template !== insertionElementTagData.subtemplate;
+ if (template) {
+ delete options.tags[tagName];
+ var tagData;
+ if (renderingLightContent) {
+ if (leakScope.toLightContent) {
+ tagData = addContext(el, {
+ scope: insertionElementTagData.scope.cloneFromRef(),
+ options: insertionElementTagData.options
+ }, insertionElementTagData);
+ } else {
+ tagData = addContext(el, componentTagData, insertionElementTagData);
+ }
+ } else {
+ tagData = addContext(el, insertionElementTagData, insertionElementTagData);
+ }
+ var nodeList = nodeLists.register([el], function () {
+ if (tagData.teardown) {
+ tagData.teardown();
+ }
+ }, insertionElementTagData.parentNodeList || true, false);
+ nodeList.expression = '';
+ var frag = template(tagData.scope, tagData.options, nodeList);
+ var newNodes = makeArray(getChildNodes(frag));
+ nodeLists.replace(nodeList, frag);
+ nodeLists.update(nodeList, newNodes);
+ options.tags[tagName] = hookupFunction;
+ }
+ };
+ }
+ var Component = Construct.extend({
+ setup: function () {
+ Construct.setup.apply(this, arguments);
+ if (Component) {
+ var self = this;
+ if (!isEmptyObject(this.prototype.events)) {
+ this.Control = ComponentControl.extend(this.prototype.events);
+ }
+ var protoViewModel = this.prototype.viewModel || this.prototype.scope;
+ if (protoViewModel && this.prototype.ViewModel) {
+ throw new Error('Cannot provide both a ViewModel and a viewModel property');
+ }
+ var vmName = string.capitalize(string.camelize(this.prototype.tag)) + 'VM';
+ if (this.prototype.ViewModel) {
+ if (typeof this.prototype.ViewModel === 'function') {
+ this.ViewModel = this.prototype.ViewModel;
+ } else {
+ this.ViewModel = types.DefaultMap.extend(vmName, this.prototype.ViewModel);
+ }
+ } else {
+ if (protoViewModel) {
+ if (typeof protoViewModel === 'function') {
+ if (canReflect.isObservableLike(protoViewModel.prototype) && canReflect.isMapLike(protoViewModel.prototype)) {
+ this.ViewModel = protoViewModel;
+ } else {
+ this.viewModelHandler = protoViewModel;
+ }
+ } else {
+ if (canReflect.isObservableLike(protoViewModel) && canReflect.isMapLike(protoViewModel)) {
+ this.viewModelInstance = protoViewModel;
+ } else {
+ this.ViewModel = types.DefaultMap.extend(vmName, protoViewModel);
+ }
+ }
+ } else {
+ this.ViewModel = types.DefaultMap.extend(vmName, {});
+ }
+ }
+ if (this.prototype.template) {
+ this.renderer = this.prototype.template;
+ }
+ if (this.prototype.view) {
+ this.renderer = this.prototype.view;
+ }
+ viewCallbacks.tag(this.prototype.tag, function (el, options) {
+ new self(el, options);
+ });
+ }
+ }
+ }, {
+ setup: function (el, componentTagData) {
+ var component = this;
+ var teardownFunctions = [];
+ var initialViewModelData = {};
+ var callTeardownFunctions = function () {
+ for (var i = 0, len = teardownFunctions.length; i < len; i++) {
+ teardownFunctions[i]();
+ }
+ };
+ var setupBindings = !domData.get.call(el, 'preventDataBindings');
+ var viewModel, frag;
+ var teardownBindings;
+ if (setupBindings) {
+ var setupFn = componentTagData.setupBindings || function (el, callback, data) {
+ return stacheBindings.behaviors.viewModel(el, componentTagData, callback, data);
+ };
+ teardownBindings = setupFn(el, function (initialViewModelData) {
+ var ViewModel = component.constructor.ViewModel, viewModelHandler = component.constructor.viewModelHandler, viewModelInstance = component.constructor.viewModelInstance;
+ if (viewModelHandler) {
+ var scopeResult = viewModelHandler.call(component, initialViewModelData, componentTagData.scope, el);
+ if (canReflect.isObservableLike(scopeResult) && canReflect.isMapLike(scopeResult)) {
+ viewModelInstance = scopeResult;
+ } else if (canReflect.isObservableLike(scopeResult.prototype) && canReflect.isMapLike(scopeResult.prototype)) {
+ ViewModel = scopeResult;
+ } else {
+ ViewModel = types.DefaultMap.extend(scopeResult);
+ }
+ }
+ if (ViewModel) {
+ viewModelInstance = new component.constructor.ViewModel(initialViewModelData);
+ }
+ viewModel = viewModelInstance;
+ return viewModelInstance;
+ }, initialViewModelData);
+ }
+ this.viewModel = viewModel;
+ domData.set.call(el, 'viewModel', viewModel);
+ domData.set.call(el, 'preventDataBindings', true);
+ var options = {
+ helpers: {},
+ tags: {}
+ };
+ canEach(this.helpers || {}, function (val, prop) {
+ if (isFunction(val)) {
+ options.helpers[prop] = val.bind(viewModel);
+ }
+ });
+ if (this.constructor.Control) {
+ this._control = new this.constructor.Control(el, {
+ scope: this.viewModel,
+ viewModel: this.viewModel,
+ destroy: callTeardownFunctions
+ });
+ }
+ var leakScope = {
+ toLightContent: this.leakScope === true,
+ intoShadowContent: this.leakScope === true
+ };
+ var hasShadowTemplate = !!this.constructor.renderer;
+ var betweenTagsRenderer;
+ var betweenTagsTagData;
+ if (hasShadowTemplate) {
+ var shadowTagData;
+ if (leakScope.intoShadowContent) {
+ shadowTagData = {
+ scope: componentTagData.scope.add(new Scope.Refs()).add(this.viewModel, { viewModel: true }),
+ options: componentTagData.options.add(options)
+ };
+ } else {
+ shadowTagData = {
+ scope: Scope.refsScope().add(this.viewModel, { viewModel: true }),
+ options: new Scope.Options(options)
+ };
+ }
+ options.tags['can-slot'] = makeInsertionTagCallback('can-slot', componentTagData, shadowTagData, leakScope, function (el) {
+ return componentTagData.templates[el.getAttribute('name')];
+ });
+ options.tags.content = makeInsertionTagCallback('content', componentTagData, shadowTagData, leakScope, function () {
+ return componentTagData.subtemplate;
+ });
+ betweenTagsRenderer = this.constructor.renderer;
+ betweenTagsTagData = shadowTagData;
+ } else {
+ var lightTemplateTagData = {
+ scope: componentTagData.scope.add(this.viewModel, { viewModel: true }),
+ options: componentTagData.options.add(options)
+ };
+ betweenTagsTagData = lightTemplateTagData;
+ betweenTagsRenderer = componentTagData.subtemplate || el.ownerDocument.createDocumentFragment.bind(el.ownerDocument);
+ }
+ var nodeList = nodeLists.register([], function () {
+ domDispatch.call(el, 'beforeremove', [], false);
+ if (teardownBindings) {
+ teardownBindings();
+ }
+ }, componentTagData.parentNodeList || true, false);
+ nodeList.expression = '<' + this.tag + '>';
+ teardownFunctions.push(function () {
+ nodeLists.unregister(nodeList);
+ });
+ frag = betweenTagsRenderer(betweenTagsTagData.scope, betweenTagsTagData.options, nodeList);
+ domMutate.appendChild.call(el, frag);
+ nodeLists.update(nodeList, getChildNodes(el));
+ }
+ });
+ module.exports = namespace.Component = Component;
+});
+/*[global-shim-end]*/
+(function(global) { // jshint ignore:line
+ global._define = global.define;
+ global.define = global.define.orig;
+}
+)(typeof self == "object" && self.Object == Object ? self : window);
\ No newline at end of file