diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..57206ce --- /dev/null +++ b/.gitignore @@ -0,0 +1,4 @@ +.idea +node_modules +npm-debug.log +dist \ No newline at end of file diff --git a/README.md b/README.md index b6bbf71..5d5cb40 100644 --- a/README.md +++ b/README.md @@ -1,18 +1,25 @@ -# Simple Angular 2 app written in TypeScript +# Simple Angular 2 app written in TypeScript with Gulp Automation -## Use latest TypeScript compiler -TypeScript 1.5 beta includes everything you need. Make sure to upgrade, even if you installed TypeScript previously. +## Install Gulp - $ npm install -g typescript@^1.5.0-beta + $ npm install -g gulp # Or sudo npm install -g gulp -## Start up the compiler +## Compile your source and libs and move to dist - $ cd ts-quickstart - $ tsc -w - message TS6042: Compilation complete. Watching for file changes. + $ cd angular2-gulp-typescript + $ gulp + Using gulpfile ....angular2-gulp-typescript/gulpfile.js + Starting 'js'... + Starting 'libs'... + Starting 'html'... + Finished 'html' after 1.11 s + Finished 'js' after 1.13 s + Finished 'libs' after 1.12 s + Starting 'default'... + Finished 'default' after 14 μs -## Use a TypeScript-aware editor -We have good experience using these editors: +## Edit your app (src folder) +We have good experience using these Typescript aware editors: * [Visual Studio Code](https://code.visualstudio.com/) * [Webstorm 10](https://www.jetbrains.com/webstorm/download/) @@ -20,12 +27,14 @@ We have good experience using these editors: * [Sublime Text](http://www.sublimetext.com/3) with [Typescript-Sublime-Plugin](https://github.com/Microsoft/Typescript-Sublime-plugin#installation) ## Load the app -If you want to get up and running immediately, copy the completed sources: - - $ cp complete/* . - From the directory that contains index.html: $ npm install -g http-server # Or sudo npm install -g http-server + $ cd dist $ http-server # Creates a server at localhost:8080 # In a browser, visit localhost:8080/index.html + +## Clean dist + + $ cd angular2-gulp-typescript + $ gulp clean diff --git a/bundle/angular2.dev.js b/bundle/angular2.dev.js index aaa8713..2fac104 100644 --- a/bundle/angular2.dev.js +++ b/bundle/angular2.dev.js @@ -1,8 +1,33 @@ +(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o= 0; i--) { - if (typeof args[i] === 'function') { - args[i] = zone.bind(args[i]); - } - } - return args; -}; + function lib$es6$promise$asap$$useMutationObserver() { + var iterations = 0; + var observer = new lib$es6$promise$asap$$BrowserMutationObserver(lib$es6$promise$asap$$flush); + var node = document.createTextNode(''); + observer.observe(node, { characterData: true }); + return function() { + node.data = (iterations = ++iterations % 2); + }; + } -Zone.bindArgumentsOnce = function (args) { - for (var i = args.length - 1; i >= 0; i--) { - if (typeof args[i] === 'function') { - args[i] = zone.bindOnce(args[i]); + // web worker + function lib$es6$promise$asap$$useMessageChannel() { + var channel = new MessageChannel(); + channel.port1.onmessage = lib$es6$promise$asap$$flush; + return function () { + channel.port2.postMessage(0); + }; } - } - return args; -}; -/* - * patch a fn that returns a promise - */ -Zone.bindPromiseFn = (function() { - // if the browser natively supports Promises, we can just return a native promise - if (window.Promise) { - return function (delegate) { + function lib$es6$promise$asap$$useSetTimeout() { return function() { - var delegatePromise = delegate.apply(this, arguments); - if (delegatePromise instanceof Promise) { - return delegatePromise; - } else { - return new Promise(function(resolve, reject) { - delegatePromise.then(resolve, reject); - }); - } + setTimeout(lib$es6$promise$asap$$flush, 1); }; - }; - } else { - // if the browser does not have native promises, we have to patch each promise instance - return function (delegate) { - return function () { - return patchThenable(delegate.apply(this, arguments)); - }; - }; - } + } - function patchThenable(thenable) { - var then = thenable.then; - thenable.then = function () { - var args = Zone.bindArguments(arguments); - var nextThenable = then.apply(thenable, args); - return patchThenable(nextThenable); - }; + var lib$es6$promise$asap$$queue = new Array(1000); + function lib$es6$promise$asap$$flush() { + for (var i = 0; i < lib$es6$promise$asap$$len; i+=2) { + var callback = lib$es6$promise$asap$$queue[i]; + var arg = lib$es6$promise$asap$$queue[i+1]; - var ocatch = thenable.catch; - thenable.catch = function () { - var args = Zone.bindArguments(arguments); - var nextThenable = ocatch.apply(thenable, args); - return patchThenable(nextThenable); - }; - return thenable; - } -}()); + callback(arg); + lib$es6$promise$asap$$queue[i] = undefined; + lib$es6$promise$asap$$queue[i+1] = undefined; + } -Zone.patchableFn = function (obj, fnNames) { - fnNames.forEach(function (name) { - var delegate = obj[name]; - zone[name] = function () { - return delegate.apply(obj, arguments); - }; + lib$es6$promise$asap$$len = 0; + } - obj[name] = function () { - return zone[name].apply(this, arguments); - }; - }); -}; + function lib$es6$promise$asap$$attemptVertex() { + try { + var r = require; + var vertx = r('vertx'); + lib$es6$promise$asap$$vertxNext = vertx.runOnLoop || vertx.runOnContext; + return lib$es6$promise$asap$$useVertxTimer(); + } catch(e) { + return lib$es6$promise$asap$$useSetTimeout(); + } + } -Zone.patchProperty = function (obj, prop) { - var desc = Object.getOwnPropertyDescriptor(obj, prop) || { - enumerable: true, - configurable: true - }; + var lib$es6$promise$asap$$scheduleFlush; + // Decide what async method to use to triggering processing of queued callbacks: + if (lib$es6$promise$asap$$isNode) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useNextTick(); + } else if (lib$es6$promise$asap$$BrowserMutationObserver) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMutationObserver(); + } else if (lib$es6$promise$asap$$isWorker) { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useMessageChannel(); + } else if (lib$es6$promise$asap$$browserWindow === undefined && typeof require === 'function') { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$attemptVertex(); + } else { + lib$es6$promise$asap$$scheduleFlush = lib$es6$promise$asap$$useSetTimeout(); + } - // A property descriptor cannot have getter/setter and be writable - // deleting the writable and value properties avoids this error: - // - // TypeError: property descriptors must not specify a value or be writable when a - // getter or setter has been specified - delete desc.writable; - delete desc.value; + function lib$es6$promise$$internal$$noop() {} - // substr(2) cuz 'onclick' -> 'click', etc - var eventName = prop.substr(2); - var _prop = '_' + prop; + var lib$es6$promise$$internal$$PENDING = void 0; + var lib$es6$promise$$internal$$FULFILLED = 1; + var lib$es6$promise$$internal$$REJECTED = 2; - desc.set = function (fn) { - if (this[_prop]) { - this.removeEventListener(eventName, this[_prop]); + var lib$es6$promise$$internal$$GET_THEN_ERROR = new lib$es6$promise$$internal$$ErrorObject(); + + function lib$es6$promise$$internal$$selfFullfillment() { + return new TypeError("You cannot resolve a promise with itself"); } - if (typeof fn === 'function') { - this[_prop] = fn; - this.addEventListener(eventName, fn, false); - } else { - this[_prop] = null; + function lib$es6$promise$$internal$$cannotReturnOwn() { + return new TypeError('A promises callback cannot return that same promise.'); } - }; - desc.get = function () { - return this[_prop]; - }; + function lib$es6$promise$$internal$$getThen(promise) { + try { + return promise.then; + } catch(error) { + lib$es6$promise$$internal$$GET_THEN_ERROR.error = error; + return lib$es6$promise$$internal$$GET_THEN_ERROR; + } + } - Object.defineProperty(obj, prop, desc); -}; + function lib$es6$promise$$internal$$tryThen(then, value, fulfillmentHandler, rejectionHandler) { + try { + then.call(value, fulfillmentHandler, rejectionHandler); + } catch(e) { + return e; + } + } -Zone.patchProperties = function (obj, properties) { + function lib$es6$promise$$internal$$handleForeignThenable(promise, thenable, then) { + lib$es6$promise$asap$$default(function(promise) { + var sealed = false; + var error = lib$es6$promise$$internal$$tryThen(then, thenable, function(value) { + if (sealed) { return; } + sealed = true; + if (thenable !== value) { + lib$es6$promise$$internal$$resolve(promise, value); + } else { + lib$es6$promise$$internal$$fulfill(promise, value); + } + }, function(reason) { + if (sealed) { return; } + sealed = true; - (properties || (function () { - var props = []; - for (var prop in obj) { - props.push(prop); + lib$es6$promise$$internal$$reject(promise, reason); + }, 'Settle: ' + (promise._label || ' unknown promise')); + + if (!sealed && error) { + sealed = true; + lib$es6$promise$$internal$$reject(promise, error); + } + }, promise); + } + + function lib$es6$promise$$internal$$handleOwnThenable(promise, thenable) { + if (thenable._state === lib$es6$promise$$internal$$FULFILLED) { + lib$es6$promise$$internal$$fulfill(promise, thenable._result); + } else if (thenable._state === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, thenable._result); + } else { + lib$es6$promise$$internal$$subscribe(thenable, undefined, function(value) { + lib$es6$promise$$internal$$resolve(promise, value); + }, function(reason) { + lib$es6$promise$$internal$$reject(promise, reason); + }); } - return props; - }()). - filter(function (propertyName) { - return propertyName.substr(0,2) === 'on'; - })). - forEach(function (eventName) { - Zone.patchProperty(obj, eventName); - }); -}; + } -Zone.patchEventTargetMethods = function (obj) { - var addDelegate = obj.addEventListener; - obj.addEventListener = function (eventName, fn) { - arguments[1] = fn._bound = zone.bind(fn); - return addDelegate.apply(this, arguments); - }; + function lib$es6$promise$$internal$$handleMaybeThenable(promise, maybeThenable) { + if (maybeThenable.constructor === promise.constructor) { + lib$es6$promise$$internal$$handleOwnThenable(promise, maybeThenable); + } else { + var then = lib$es6$promise$$internal$$getThen(maybeThenable); - var removeDelegate = obj.removeEventListener; - obj.removeEventListener = function (eventName, fn) { - arguments[1] = arguments[1]._bound || arguments[1]; - var result = removeDelegate.apply(this, arguments); - zone.dequeueTask(fn); - return result; - }; -}; + if (then === lib$es6$promise$$internal$$GET_THEN_ERROR) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$GET_THEN_ERROR.error); + } else if (then === undefined) { + lib$es6$promise$$internal$$fulfill(promise, maybeThenable); + } else if (lib$es6$promise$utils$$isFunction(then)) { + lib$es6$promise$$internal$$handleForeignThenable(promise, maybeThenable, then); + } else { + lib$es6$promise$$internal$$fulfill(promise, maybeThenable); + } + } + } -Zone.patch = function patch () { - Zone.patchSetClearFn(window, [ - 'timeout', - 'interval', - 'immediate' - ]); + function lib$es6$promise$$internal$$resolve(promise, value) { + if (promise === value) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$selfFullfillment()); + } else if (lib$es6$promise$utils$$objectOrFunction(value)) { + lib$es6$promise$$internal$$handleMaybeThenable(promise, value); + } else { + lib$es6$promise$$internal$$fulfill(promise, value); + } + } - Zone.patchSetFn(window, [ - 'requestAnimationFrame', - 'mozRequestAnimationFrame', - 'webkitRequestAnimationFrame' - ]); + function lib$es6$promise$$internal$$publishRejection(promise) { + if (promise._onerror) { + promise._onerror(promise._result); + } - Zone.patchableFn(window, ['alert', 'prompt']); + lib$es6$promise$$internal$$publish(promise); + } - // patched properties depend on addEventListener, so this needs to come first - if (window.EventTarget) { - Zone.patchEventTargetMethods(window.EventTarget.prototype); + function lib$es6$promise$$internal$$fulfill(promise, value) { + if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; } - // Note: EventTarget is not available in all browsers, - // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget - } else { - [ 'ApplicationCache', - 'EventSource', - 'FileReader', - 'InputMethodContext', - 'MediaController', - 'MessagePort', - 'Node', - 'Performance', - 'SVGElementInstance', - 'SharedWorker', - 'TextTrack', - 'TextTrackCue', - 'TextTrackList', - 'WebKitNamedFlow', - 'Window', - 'Worker', - 'WorkerGlobalScope', - 'XMLHttpRequestEventTarget', - 'XMLHttpRequestUpload' - ]. - filter(function (thing) { - return window[thing]; - }). - map(function (thing) { - return window[thing].prototype; - }). - forEach(Zone.patchEventTargetMethods); - } + promise._result = value; + promise._state = lib$es6$promise$$internal$$FULFILLED; - if (Zone.canPatchViaPropertyDescriptor()) { - Zone.patchViaPropertyDescriptor(); - } else { - Zone.patchViaCapturingAllTheEvents(); - Zone.patchClass('XMLHttpRequest'); - Zone.patchWebSocket(); - } + if (promise._subscribers.length !== 0) { + lib$es6$promise$asap$$default(lib$es6$promise$$internal$$publish, promise); + } + } - // patch promises - if (window.Promise) { - Zone.patchPrototype(Promise.prototype, [ - 'then', - 'catch' - ]); - } - Zone.patchMutationObserverClass('MutationObserver'); - Zone.patchMutationObserverClass('WebKitMutationObserver'); - Zone.patchDefineProperty(); - Zone.patchRegisterElement(); -}; + function lib$es6$promise$$internal$$reject(promise, reason) { + if (promise._state !== lib$es6$promise$$internal$$PENDING) { return; } + promise._state = lib$es6$promise$$internal$$REJECTED; + promise._result = reason; -// -Zone.canPatchViaPropertyDescriptor = function () { - if (!Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') && - typeof Element !== 'undefined') { - // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364 - // IDL interface attributes are not configurable - var desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick'); - if (desc && !desc.configurable) return false; - } + lib$es6$promise$asap$$default(lib$es6$promise$$internal$$publishRejection, promise); + } - Object.defineProperty(HTMLElement.prototype, 'onclick', { - get: function () { - return true; + function lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection) { + var subscribers = parent._subscribers; + var length = subscribers.length; + + parent._onerror = null; + + subscribers[length] = child; + subscribers[length + lib$es6$promise$$internal$$FULFILLED] = onFulfillment; + subscribers[length + lib$es6$promise$$internal$$REJECTED] = onRejection; + + if (length === 0 && parent._state) { + lib$es6$promise$asap$$default(lib$es6$promise$$internal$$publish, parent); + } } - }); - var elt = document.createElement('div'); - var result = !!elt.onclick; - Object.defineProperty(HTMLElement.prototype, 'onclick', {}); - return result; -}; -// for browsers that we can patch the descriptor: -// - eventually Chrome once this bug gets resolved -// - Firefox -Zone.patchViaPropertyDescriptor = function () { - Zone.patchProperties(HTMLElement.prototype, Zone.onEventNames); - Zone.patchProperties(XMLHttpRequest.prototype); -}; + function lib$es6$promise$$internal$$publish(promise) { + var subscribers = promise._subscribers; + var settled = promise._state; -// Whenever any event fires, we check the event target and all parents -// for `onwhatever` properties and replace them with zone-bound functions -// - Chrome (for now) -Zone.patchViaCapturingAllTheEvents = function () { - Zone.eventNames.forEach(function (property) { - var onproperty = 'on' + property; - document.addEventListener(property, function (event) { - var elt = event.target, bound; - while (elt) { - if (elt[onproperty] && !elt[onproperty]._unbound) { - bound = zone.bind(elt[onproperty]); - bound._unbound = elt[onproperty]; - elt[onproperty] = bound; + if (subscribers.length === 0) { return; } + + var child, callback, detail = promise._result; + + for (var i = 0; i < subscribers.length; i += 3) { + child = subscribers[i]; + callback = subscribers[i + settled]; + + if (child) { + lib$es6$promise$$internal$$invokeCallback(settled, child, callback, detail); + } else { + callback(detail); } - elt = elt.parentElement; } - }, true); - }); -}; -// we have to patch the instance since the proto is non-configurable -Zone.patchWebSocket = function() { - var WS = window.WebSocket; - window.WebSocket = function(a, b) { - var socket = arguments.length > 1 ? new WS(a, b) : new WS(a); - Zone.patchProperties(socket, ['onclose', 'onerror', 'onmessage', 'onopen']); - return socket; - }; -} + promise._subscribers.length = 0; + } + function lib$es6$promise$$internal$$ErrorObject() { + this.error = null; + } -// wrap some native API on `window` -Zone.patchClass = function (className) { - var OriginalClass = window[className]; - if (!OriginalClass) { - return; - } - window[className] = function () { - var a = Zone.bindArguments(arguments); - switch (a.length) { - case 0: this._o = new OriginalClass(); break; - case 1: this._o = new OriginalClass(a[0]); break; - case 2: this._o = new OriginalClass(a[0], a[1]); break; - case 3: this._o = new OriginalClass(a[0], a[1], a[2]); break; - case 4: this._o = new OriginalClass(a[0], a[1], a[2], a[3]); break; - default: throw new Error('what are you even doing?'); + var lib$es6$promise$$internal$$TRY_CATCH_ERROR = new lib$es6$promise$$internal$$ErrorObject(); + + function lib$es6$promise$$internal$$tryCatch(callback, detail) { + try { + return callback(detail); + } catch(e) { + lib$es6$promise$$internal$$TRY_CATCH_ERROR.error = e; + return lib$es6$promise$$internal$$TRY_CATCH_ERROR; + } } - }; - var instance = new OriginalClass(className.substr(-16) === 'MutationObserver' ? function () {} : undefined); + function lib$es6$promise$$internal$$invokeCallback(settled, promise, callback, detail) { + var hasCallback = lib$es6$promise$utils$$isFunction(callback), + value, error, succeeded, failed; + + if (hasCallback) { + value = lib$es6$promise$$internal$$tryCatch(callback, detail); + + if (value === lib$es6$promise$$internal$$TRY_CATCH_ERROR) { + failed = true; + error = value.error; + value = null; + } else { + succeeded = true; + } + + if (promise === value) { + lib$es6$promise$$internal$$reject(promise, lib$es6$promise$$internal$$cannotReturnOwn()); + return; + } - var prop; - for (prop in instance) { - (function (prop) { - if (typeof instance[prop] === 'function') { - window[className].prototype[prop] = function () { - return this._o[prop].apply(this._o, arguments); - }; } else { - Object.defineProperty(window[className].prototype, prop, { - set: function (fn) { - if (typeof fn === 'function') { - this._o[prop] = zone.bind(fn); - } else { - this._o[prop] = fn; - } - }, - get: function () { - return this._o[prop]; - } + value = detail; + succeeded = true; + } + + if (promise._state !== lib$es6$promise$$internal$$PENDING) { + // noop + } else if (hasCallback && succeeded) { + lib$es6$promise$$internal$$resolve(promise, value); + } else if (failed) { + lib$es6$promise$$internal$$reject(promise, error); + } else if (settled === lib$es6$promise$$internal$$FULFILLED) { + lib$es6$promise$$internal$$fulfill(promise, value); + } else if (settled === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, value); + } + } + + function lib$es6$promise$$internal$$initializePromise(promise, resolver) { + try { + resolver(function resolvePromise(value){ + lib$es6$promise$$internal$$resolve(promise, value); + }, function rejectPromise(reason) { + lib$es6$promise$$internal$$reject(promise, reason); }); + } catch(e) { + lib$es6$promise$$internal$$reject(promise, e); } - }(prop)); - }; -}; + } + function lib$es6$promise$enumerator$$Enumerator(Constructor, input) { + var enumerator = this; -// wrap some native API on `window` -Zone.patchMutationObserverClass = function (className) { - var OriginalClass = window[className]; - if (!OriginalClass) { - return; - } - window[className] = function (fn) { - this._o = new OriginalClass(zone.bind(fn, true)); - }; + enumerator._instanceConstructor = Constructor; + enumerator.promise = new Constructor(lib$es6$promise$$internal$$noop); - var instance = new OriginalClass(function () {}); + if (enumerator._validateInput(input)) { + enumerator._input = input; + enumerator.length = input.length; + enumerator._remaining = input.length; - window[className].prototype.disconnect = function () { - var result = this._o.disconnect.apply(this._o, arguments); - this._active && zone.dequeueTask(); - this._active = false; - return result; - }; + enumerator._init(); - window[className].prototype.observe = function () { - if (!this._active) { - zone.enqueueTask(); + if (enumerator.length === 0) { + lib$es6$promise$$internal$$fulfill(enumerator.promise, enumerator._result); + } else { + enumerator.length = enumerator.length || 0; + enumerator._enumerate(); + if (enumerator._remaining === 0) { + lib$es6$promise$$internal$$fulfill(enumerator.promise, enumerator._result); + } + } + } else { + lib$es6$promise$$internal$$reject(enumerator.promise, enumerator._validationError()); + } } - this._active = true; - return this._o.observe.apply(this._o, arguments); - }; - var prop; - for (prop in instance) { - (function (prop) { - if (typeof window[className].prototype !== undefined) { - return; + lib$es6$promise$enumerator$$Enumerator.prototype._validateInput = function(input) { + return lib$es6$promise$utils$$isArray(input); + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._validationError = function() { + return new Error('Array Methods must be provided an Array'); + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._init = function() { + this._result = new Array(this.length); + }; + + var lib$es6$promise$enumerator$$default = lib$es6$promise$enumerator$$Enumerator; + + lib$es6$promise$enumerator$$Enumerator.prototype._enumerate = function() { + var enumerator = this; + + var length = enumerator.length; + var promise = enumerator.promise; + var input = enumerator._input; + + for (var i = 0; promise._state === lib$es6$promise$$internal$$PENDING && i < length; i++) { + enumerator._eachEntry(input[i], i); } - if (typeof instance[prop] === 'function') { - window[className].prototype[prop] = function () { - return this._o[prop].apply(this._o, arguments); - }; + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._eachEntry = function(entry, i) { + var enumerator = this; + var c = enumerator._instanceConstructor; + + if (lib$es6$promise$utils$$isMaybeThenable(entry)) { + if (entry.constructor === c && entry._state !== lib$es6$promise$$internal$$PENDING) { + entry._onerror = null; + enumerator._settledAt(entry._state, i, entry._result); + } else { + enumerator._willSettleAt(c.resolve(entry), i); + } } else { - Object.defineProperty(window[className].prototype, prop, { - set: function (fn) { - if (typeof fn === 'function') { - this._o[prop] = zone.bind(fn); - } else { - this._o[prop] = fn; - } - }, - get: function () { - return this._o[prop]; - } - }); + enumerator._remaining--; + enumerator._result[i] = entry; } - }(prop)); - } -}; + }; -// might need similar for object.freeze -// i regret nothing -Zone.patchDefineProperty = function () { - var _defineProperty = Object.defineProperty; - var _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; - var _create = Object.create; + lib$es6$promise$enumerator$$Enumerator.prototype._settledAt = function(state, i, value) { + var enumerator = this; + var promise = enumerator.promise; - Object.defineProperty = function (obj, prop, desc) { - if (isUnconfigurable(obj, prop)) { - throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj); - } - if (prop !== 'prototype') { - desc = rewriteDescriptor(obj, prop, desc); - } - return _defineProperty(obj, prop, desc); - }; + if (promise._state === lib$es6$promise$$internal$$PENDING) { + enumerator._remaining--; - Object.defineProperties = function (obj, props) { - Object.keys(props).forEach(function (prop) { - Object.defineProperty(obj, prop, props[prop]); - }); - return obj; - }; + if (state === lib$es6$promise$$internal$$REJECTED) { + lib$es6$promise$$internal$$reject(promise, value); + } else { + enumerator._result[i] = value; + } + } - Object.create = function (obj, proto) { - if (typeof proto === 'object') { - Object.keys(proto).forEach(function (prop) { - proto[prop] = rewriteDescriptor(obj, prop, proto[prop]); + if (enumerator._remaining === 0) { + lib$es6$promise$$internal$$fulfill(promise, enumerator._result); + } + }; + + lib$es6$promise$enumerator$$Enumerator.prototype._willSettleAt = function(promise, i) { + var enumerator = this; + + lib$es6$promise$$internal$$subscribe(promise, undefined, function(value) { + enumerator._settledAt(lib$es6$promise$$internal$$FULFILLED, i, value); + }, function(reason) { + enumerator._settledAt(lib$es6$promise$$internal$$REJECTED, i, reason); }); + }; + function lib$es6$promise$promise$all$$all(entries) { + return new lib$es6$promise$enumerator$$default(this, entries).promise; } - return _create(obj, proto); - }; + var lib$es6$promise$promise$all$$default = lib$es6$promise$promise$all$$all; + function lib$es6$promise$promise$race$$race(entries) { + /*jshint validthis:true */ + var Constructor = this; - Object.getOwnPropertyDescriptor = function (obj, prop) { - var desc = _getOwnPropertyDescriptor(obj, prop); - if (isUnconfigurable(obj, prop)) { - desc.configurable = false; - } - return desc; - }; + var promise = new Constructor(lib$es6$promise$$internal$$noop); - Zone._redefineProperty = function (obj, prop, desc) { - desc = rewriteDescriptor(obj, prop, desc); - return _defineProperty(obj, prop, desc); - }; + if (!lib$es6$promise$utils$$isArray(entries)) { + lib$es6$promise$$internal$$reject(promise, new TypeError('You must pass an array to race.')); + return promise; + } - function isUnconfigurable (obj, prop) { - return obj && obj.__unconfigurables && obj.__unconfigurables[prop]; - } + var length = entries.length; - function rewriteDescriptor (obj, prop, desc) { - desc.configurable = true; - if (!desc.configurable) { - if (!obj.__unconfigurables) { - _defineProperty(obj, '__unconfigurables', { writable: true, value: {} }); + function onFulfillment(value) { + lib$es6$promise$$internal$$resolve(promise, value); } - obj.__unconfigurables[prop] = true; - } - return desc; - } -}; -Zone.patchRegisterElement = function () { - if (!('registerElement' in document)) { - return; - } - var _registerElement = document.registerElement; - var callbacks = [ - 'createdCallback', - 'attachedCallback', - 'detachedCallback', - 'attributeChangedCallback' - ]; - document.registerElement = function (name, opts) { - callbacks.forEach(function (callback) { - if (opts.prototype[callback]) { - var descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback); - if (descriptor.value) { - descriptor.value = zone.bind(descriptor.value || opts.prototype[callback]); - Zone._redefineProperty(opts.prototype, callback, descriptor); - } + function onRejection(reason) { + lib$es6$promise$$internal$$reject(promise, reason); } - }); - return _registerElement.apply(document, [name, opts]); - }; -} -Zone.eventNames = 'copy cut paste abort blur focus canplay canplaythrough change click contextmenu dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended input invalid keydown keypress keyup load loadeddata loadedmetadata loadstart message mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup pause play playing progress ratechange reset scroll seeked seeking select show stalled submit suspend timeupdate volumechange waiting mozfullscreenchange mozfullscreenerror mozpointerlockchange mozpointerlockerror error webglcontextrestored webglcontextlost webglcontextcreationerror'.split(' '); -Zone.onEventNames = Zone.eventNames.map(function (property) { - return 'on' + property; -}); + for (var i = 0; promise._state === lib$es6$promise$$internal$$PENDING && i < length; i++) { + lib$es6$promise$$internal$$subscribe(Constructor.resolve(entries[i]), undefined, onFulfillment, onRejection); + } -Zone.init = function init () { - if (typeof module !== 'undefined' && module && module.exports) { - module.exports = new Zone(); - } else { - window.zone = new Zone(); - } - Zone.patch(); -}; + return promise; + } + var lib$es6$promise$promise$race$$default = lib$es6$promise$promise$race$$race; + function lib$es6$promise$promise$resolve$$resolve(object) { + /*jshint validthis:true */ + var Constructor = this; + if (object && typeof object === 'object' && object.constructor === Constructor) { + return object; + } -Zone.init(); + var promise = new Constructor(lib$es6$promise$$internal$$noop); + lib$es6$promise$$internal$$resolve(promise, object); + return promise; + } + var lib$es6$promise$promise$resolve$$default = lib$es6$promise$promise$resolve$$resolve; + function lib$es6$promise$promise$reject$$reject(reason) { + /*jshint validthis:true */ + var Constructor = this; + var promise = new Constructor(lib$es6$promise$$internal$$noop); + lib$es6$promise$$internal$$reject(promise, reason); + return promise; + } + var lib$es6$promise$promise$reject$$default = lib$es6$promise$promise$reject$$reject; -/* - * Wrapped stacktrace - * - * We need this because in some implementations, constructing a trace is slow - * and so we want to defer accessing the trace for as long as possible - */ -Zone.Stacktrace = function (e) { - this._e = e; -}; -Zone.Stacktrace.prototype.get = function () { - if (zone.stackFramesFilter) { - return this._e.stack. - split('\n'). - filter(zone.stackFramesFilter). - join('\n'); - } - return this._e.stack; -} + var lib$es6$promise$promise$$counter = 0; -Zone.getStacktrace = function () { - function getStacktraceWithUncaughtError () { - return new Zone.Stacktrace(new Error()); - } + function lib$es6$promise$promise$$needsResolver() { + throw new TypeError('You must pass a resolver function as the first argument to the promise constructor'); + } - function getStacktraceWithCaughtError () { - try { - throw new Error(); - } catch (e) { - return new Zone.Stacktrace(e); + function lib$es6$promise$promise$$needsNew() { + throw new TypeError("Failed to construct 'Promise': Please use the 'new' operator, this object constructor cannot be called as a function."); } - } - // Some implementations of exception handling don't create a stack trace if the exception - // isn't thrown, however it's faster not to actually throw the exception. - var stack = getStacktraceWithUncaughtError(); - if (stack && stack._e.stack) { - Zone.getStacktrace = getStacktraceWithUncaughtError; - return stack; - } else { - Zone.getStacktrace = getStacktraceWithCaughtError; - return Zone.getStacktrace(); - } -}; + var lib$es6$promise$promise$$default = lib$es6$promise$promise$$Promise; + /** + Promise objects represent the eventual result of an asynchronous operation. The + primary way of interacting with a promise is through its `then` method, which + registers callbacks to receive either a promise’s eventual value or the reason + why the promise cannot be fulfilled. -Zone.longStackTraceZone = { - getLongStacktrace: function (exception) { - var trace = []; - var zone = this; - if (exception) { - if (zone.stackFramesFilter) { - trace.push(exception.stack.split('\n'). - filter(zone.stackFramesFilter). - join('\n')); + Terminology + ----------- + + - `promise` is an object or function with a `then` method whose behavior conforms to this specification. + - `thenable` is an object or function that defines a `then` method. + - `value` is any legal JavaScript value (including undefined, a thenable, or a promise). + - `exception` is a value that is thrown using the throw statement. + - `reason` is a value that indicates why a promise was rejected. + - `settled` the final resting state of a promise, fulfilled or rejected. + + A promise can be in one of three states: pending, fulfilled, or rejected. + + Promises that are fulfilled have a fulfillment value and are in the fulfilled + state. Promises that are rejected have a rejection reason and are in the + rejected state. A fulfillment value is never a thenable. + + Promises can also be said to *resolve* a value. If this value is also a + promise, then the original promise's settled state will match the value's + settled state. So a promise that *resolves* a promise that rejects will + itself reject, and a promise that *resolves* a promise that fulfills will + itself fulfill. + + + Basic Usage: + ------------ + + ```js + var promise = new Promise(function(resolve, reject) { + // on success + resolve(value); + + // on failure + reject(reason); + }); + + promise.then(function(value) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Advanced Usage: + --------------- + + Promises shine when abstracting away asynchronous interactions such as + `XMLHttpRequest`s. + + ```js + function getJSON(url) { + return new Promise(function(resolve, reject){ + var xhr = new XMLHttpRequest(); + + xhr.open('GET', url); + xhr.onreadystatechange = handler; + xhr.responseType = 'json'; + xhr.setRequestHeader('Accept', 'application/json'); + xhr.send(); + + function handler() { + if (this.readyState === this.DONE) { + if (this.status === 200) { + resolve(this.response); + } else { + reject(new Error('getJSON: `' + url + '` failed with status: [' + this.status + ']')); + } + } + }; + }); + } + + getJSON('/posts.json').then(function(json) { + // on fulfillment + }, function(reason) { + // on rejection + }); + ``` + + Unlike callbacks, promises are great composable primitives. + + ```js + Promise.all([ + getJSON('/posts'), + getJSON('/comments') + ]).then(function(values){ + values[0] // => postsJSON + values[1] // => commentsJSON + + return values; + }); + ``` + + @class Promise + @param {function} resolver + Useful for tooling. + @constructor + */ + function lib$es6$promise$promise$$Promise(resolver) { + this._id = lib$es6$promise$promise$$counter++; + this._state = undefined; + this._result = undefined; + this._subscribers = []; + + if (lib$es6$promise$$internal$$noop !== resolver) { + if (!lib$es6$promise$utils$$isFunction(resolver)) { + lib$es6$promise$promise$$needsResolver(); + } + + if (!(this instanceof lib$es6$promise$promise$$Promise)) { + lib$es6$promise$promise$$needsNew(); + } + + lib$es6$promise$$internal$$initializePromise(this, resolver); + } + } + + lib$es6$promise$promise$$Promise.all = lib$es6$promise$promise$all$$default; + lib$es6$promise$promise$$Promise.race = lib$es6$promise$promise$race$$default; + lib$es6$promise$promise$$Promise.resolve = lib$es6$promise$promise$resolve$$default; + lib$es6$promise$promise$$Promise.reject = lib$es6$promise$promise$reject$$default; + + lib$es6$promise$promise$$Promise.prototype = { + constructor: lib$es6$promise$promise$$Promise, + + /** + The primary way of interacting with a promise is through its `then` method, + which registers callbacks to receive either a promise's eventual value or the + reason why the promise cannot be fulfilled. + + ```js + findUser().then(function(user){ + // user is available + }, function(reason){ + // user is unavailable, and you are given the reason why + }); + ``` + + Chaining + -------- + + The return value of `then` is itself a promise. This second, 'downstream' + promise is resolved with the return value of the first promise's fulfillment + or rejection handler, or rejected if the handler throws an exception. + + ```js + findUser().then(function (user) { + return user.name; + }, function (reason) { + return 'default name'; + }).then(function (userName) { + // If `findUser` fulfilled, `userName` will be the user's name, otherwise it + // will be `'default name'` + }); + + findUser().then(function (user) { + throw new Error('Found user, but still unhappy'); + }, function (reason) { + throw new Error('`findUser` rejected and we're unhappy'); + }).then(function (value) { + // never reached + }, function (reason) { + // if `findUser` fulfilled, `reason` will be 'Found user, but still unhappy'. + // If `findUser` rejected, `reason` will be '`findUser` rejected and we're unhappy'. + }); + ``` + If the downstream promise does not specify a rejection handler, rejection reasons will be propagated further downstream. + + ```js + findUser().then(function (user) { + throw new PedagogicalException('Upstream error'); + }).then(function (value) { + // never reached + }).then(function (value) { + // never reached + }, function (reason) { + // The `PedgagocialException` is propagated all the way down to here + }); + ``` + + Assimilation + ------------ + + Sometimes the value you want to propagate to a downstream promise can only be + retrieved asynchronously. This can be achieved by returning a promise in the + fulfillment or rejection handler. The downstream promise will then be pending + until the returned promise is settled. This is called *assimilation*. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // The user's comments are now available + }); + ``` + + If the assimliated promise rejects, then the downstream promise will also reject. + + ```js + findUser().then(function (user) { + return findCommentsByAuthor(user); + }).then(function (comments) { + // If `findCommentsByAuthor` fulfills, we'll have the value here + }, function (reason) { + // If `findCommentsByAuthor` rejects, we'll have the reason here + }); + ``` + + Simple Example + -------------- + + Synchronous Example + + ```javascript + var result; + + try { + result = findResult(); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + findResult(function(result, err){ + if (err) { + // failure + } else { + // success + } + }); + ``` + + Promise Example; + + ```javascript + findResult().then(function(result){ + // success + }, function(reason){ + // failure + }); + ``` + + Advanced Example + -------------- + + Synchronous Example + + ```javascript + var author, books; + + try { + author = findAuthor(); + books = findBooksByAuthor(author); + // success + } catch(reason) { + // failure + } + ``` + + Errback Example + + ```js + + function foundBooks(books) { + + } + + function failure(reason) { + + } + + findAuthor(function(author, err){ + if (err) { + failure(err); + // failure + } else { + try { + findBoooksByAuthor(author, function(books, err) { + if (err) { + failure(err); + } else { + try { + foundBooks(books); + } catch(reason) { + failure(reason); + } + } + }); + } catch(error) { + failure(err); + } + // success + } + }); + ``` + + Promise Example; + + ```javascript + findAuthor(). + then(findBooksByAuthor). + then(function(books){ + // found books + }).catch(function(reason){ + // something went wrong + }); + ``` + + @method then + @param {Function} onFulfilled + @param {Function} onRejected + Useful for tooling. + @return {Promise} + */ + then: function(onFulfillment, onRejection) { + var parent = this; + var state = parent._state; + + if (state === lib$es6$promise$$internal$$FULFILLED && !onFulfillment || state === lib$es6$promise$$internal$$REJECTED && !onRejection) { + return this; + } + + var child = new this.constructor(lib$es6$promise$$internal$$noop); + var result = parent._result; + + if (state) { + var callback = arguments[state - 1]; + lib$es6$promise$asap$$default(function(){ + lib$es6$promise$$internal$$invokeCallback(state, child, callback, result); + }); + } else { + lib$es6$promise$$internal$$subscribe(parent, child, onFulfillment, onRejection); + } + + return child; + }, + + /** + `catch` is simply sugar for `then(undefined, onRejection)` which makes it the same + as the catch block of a try/catch statement. + + ```js + function findAuthor(){ + throw new Error('couldn't find that author'); + } + + // synchronous + try { + findAuthor(); + } catch(reason) { + // something went wrong + } + + // async with promises + findAuthor().catch(function(reason){ + // something went wrong + }); + ``` + + @method catch + @param {Function} onRejection + Useful for tooling. + @return {Promise} + */ + 'catch': function(onRejection) { + return this.then(null, onRejection); + } + }; + function lib$es6$promise$polyfill$$polyfill() { + var local; + + if (typeof global !== 'undefined') { + local = global; + } else if (typeof self !== 'undefined') { + local = self; } else { - trace.push(exception.stack); + try { + local = Function('return this')(); + } catch (e) { + throw new Error('polyfill failed because global object is unavailable in this environment'); + } } + + var P = local.Promise; + + if (P && Object.prototype.toString.call(P.resolve()) === '[object Promise]' && !P.cast) { + return; + } + + local.Promise = lib$es6$promise$promise$$default; } - var now = Date.now(); - while (zone && zone.constructedAtException) { - trace.push( - '--- ' + (Date(zone.constructedAtTime)).toString() + - ' - ' + (now - zone.constructedAtTime) + 'ms ago', - zone.constructedAtException.get()); - zone = zone.parent; + var lib$es6$promise$polyfill$$default = lib$es6$promise$polyfill$$polyfill; + + var lib$es6$promise$umd$$ES6Promise = { + 'Promise': lib$es6$promise$promise$$default, + 'polyfill': lib$es6$promise$polyfill$$default + }; + + /* global define:true module:true window: true */ + if (typeof define === 'function' && define['amd']) { + define(function() { return lib$es6$promise$umd$$ES6Promise; }); + } else if (typeof module !== 'undefined' && module['exports']) { + module['exports'] = lib$es6$promise$umd$$ES6Promise; + } else if (typeof this !== 'undefined') { + this['ES6Promise'] = lib$es6$promise$umd$$ES6Promise; } - return trace.join('\n'); - }, - stackFramesFilter: function (line) { - return line.indexOf('zone.js') === -1; - }, + lib$es6$promise$polyfill$$default(); +}).call(this); - onError: function (exception) { - var reporter = this.reporter || console.log.bind(console); - reporter(exception.toString()); - reporter(this.getLongStacktrace(exception)); - }, - fork: function (locals) { - var newZone = this._fork(locals); - newZone.constructedAtException = Zone.getStacktrace(); - newZone.constructedAtTime = Date.now(); - return newZone; - }, +}).call(this,{},typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],4:[function(require,module,exports){ +(function (global){ +'use strict'; + +function scheduleMicrotask(fn) { + asap(this.bind(fn)); +} + +function addMicrotaskSupport(zoneClass) { + zoneClass.prototype.scheduleMicrotask = scheduleMicrotask; + return zoneClass; +} - _fork: zone.fork +module.exports = { + addMicrotaskSupport: addMicrotaskSupport }; +// TODO(vicb): There are plan to be able to use asap() from es6-promise +// see https://github.com/jakearchibald/es6-promise/pull/113 +// for now adapt code from asap.js in es6-promise +// Note: the node support has been dropped here -/*! ***************************************************************************** -Copyright (C) Microsoft. All rights reserved. -Licensed under the Apache License, Version 2.0 (the "License"); you may not use -this file except in compliance with the License. You may obtain a copy of the -License at http://www.apache.org/licenses/LICENSE-2.0 - -Unless required by applicable law or agreed to in writing, software -distributed under the License is distributed on an "AS IS" BASIS, -WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - -See the License for the specific language governing permissions and -limitations under the License. -***************************************************************************** */ -"use strict"; -var Reflect; -(function (Reflect) { - // Load global or shim versions of Map, Set, and WeakMap - var functionPrototype = Object.getPrototypeOf(Function); - var _Map = typeof Map === "function" ? Map : CreateMapPolyfill(); - var _Set = typeof Set === "function" ? Set : CreateSetPolyfill(); - var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill(); - // [[Metadata]] internal slot - var __Metadata__ = new _WeakMap(); - /** - * Applies a set of decorators to a property of a target object. - * @param decorators An array of decorators. - * @param target The target object. - * @param targetKey (Optional) The property key to decorate. - * @param targetDescriptor (Optional) The property descriptor for the target key - * @remarks Decorators are applied in reverse order. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * C = Reflect.decorate(decoratorsArray, C); - * - * // property (on constructor) - * Reflect.decorate(decoratorsArray, C, "staticProperty"); - * - * // property (on prototype) - * Reflect.decorate(decoratorsArray, C.prototype, "property"); - * - * // method (on constructor) - * Object.defineProperty(C, "staticMethod", - * Reflect.decorate(decoratorsArray, C, "staticMethod", - * Object.getOwnPropertyDescriptor(C, "staticMethod"))); - * - * // method (on prototype) - * Object.defineProperty(C.prototype, "method", - * Reflect.decorate(decoratorsArray, C.prototype, "method", - * Object.getOwnPropertyDescriptor(C.prototype, "method"))); - * - */ - function decorate(decorators, target, targetKey, targetDescriptor) { - if (!IsUndefined(targetDescriptor)) { - if (!IsArray(decorators)) { - throw new TypeError(); - } - else if (!IsObject(target)) { - throw new TypeError(); - } - else if (IsUndefined(targetKey)) { - throw new TypeError(); - } - else if (!IsObject(targetDescriptor)) { - throw new TypeError(); - } - targetKey = ToPropertyKey(targetKey); - return DecoratePropertyWithDescriptor(decorators, target, targetKey, targetDescriptor); - } - else if (!IsUndefined(targetKey)) { - if (!IsArray(decorators)) { - throw new TypeError(); - } - else if (!IsObject(target)) { - throw new TypeError(); - } - targetKey = ToPropertyKey(targetKey); - return DecoratePropertyWithoutDescriptor(decorators, target, targetKey); - } - else { - if (!IsArray(decorators)) { - throw new TypeError(); - } - else if (!IsConstructor(target)) { - throw new TypeError(); - } - return DecorateConstructor(decorators, target); - } - } - Reflect.decorate = decorate; - /** - * A default metadata decorator factory that can be used on a class, class member, or parameter. - * @param metadataKey The key for the metadata entry. - * @param metadataValue The value for the metadata entry. - * @returns A decorator function. - * @remarks - * If `metadataKey` is already defined for the target and target key, the - * metadataValue for that key will be overwritten. - * @example - * - * // constructor - * @Reflect.metadata(key, value) - * class C { - * } - * - * // property (on constructor, TypeScript only) - * class C { - * @Reflect.metadata(key, value) - * static staticProperty; - * } - * - * // property (on prototype, TypeScript only) - * class C { - * @Reflect.metadata(key, value) - * property; - * } - * - * // method (on constructor) - * class C { - * @Reflect.metadata(key, value) - * static staticMethod() { } - * } - * - * // method (on prototype) - * class C { - * @Reflect.metadata(key, value) - * method() { } - * } - * - */ - function metadata(metadataKey, metadataValue) { - function decorator(target, targetKey) { - if (!IsUndefined(targetKey)) { - if (!IsObject(target)) { - throw new TypeError(); - } - targetKey = ToPropertyKey(targetKey); - OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey); - } - else { - if (!IsConstructor(target)) { - throw new TypeError(); - } - OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, undefined); - } - } - return decorator; - } - Reflect.metadata = metadata; - /** - * Define a unique metadata entry on the target. - * @param metadataKey A key used to store and retrieve metadata. - * @param metadataValue A value that contains attached metadata. - * @param target The target object on which to define metadata. - * @param targetKey (Optional) The property key for the target. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * Reflect.defineMetadata("custom:annotation", options, C); - * - * // property (on constructor) - * Reflect.defineMetadata("custom:annotation", options, C, "staticProperty"); - * - * // property (on prototype) - * Reflect.defineMetadata("custom:annotation", options, C.prototype, "property"); - * - * // method (on constructor) - * Reflect.defineMetadata("custom:annotation", options, C, "staticMethod"); - * - * // method (on prototype) - * Reflect.defineMetadata("custom:annotation", options, C.prototype, "method"); - * - * // decorator factory as metadata-producing annotation. - * function MyAnnotation(options): Decorator { - * return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key); - * } - * - */ - function defineMetadata(metadataKey, metadataValue, target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey); - } - Reflect.defineMetadata = defineMetadata; - /** - * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined. - * @param metadataKey A key used to store and retrieve metadata. - * @param target The target object on which the metadata is defined. - * @param targetKey (Optional) The property key for the target. - * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * result = Reflect.hasMetadata("custom:annotation", C); - * - * // property (on constructor) - * result = Reflect.hasMetadata("custom:annotation", C, "staticProperty"); - * - * // property (on prototype) - * result = Reflect.hasMetadata("custom:annotation", C.prototype, "property"); - * - * // method (on constructor) - * result = Reflect.hasMetadata("custom:annotation", C, "staticMethod"); - * - * // method (on prototype) - * result = Reflect.hasMetadata("custom:annotation", C.prototype, "method"); - * - */ - function hasMetadata(metadataKey, target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - return OrdinaryHasMetadata(metadataKey, target, targetKey); - } - Reflect.hasMetadata = hasMetadata; - /** - * Gets a value indicating whether the target object has the provided metadata key defined. - * @param metadataKey A key used to store and retrieve metadata. - * @param target The target object on which the metadata is defined. - * @param targetKey (Optional) The property key for the target. - * @returns `true` if the metadata key was defined on the target object; otherwise, `false`. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * result = Reflect.hasOwnMetadata("custom:annotation", C); - * - * // property (on constructor) - * result = Reflect.hasOwnMetadata("custom:annotation", C, "staticProperty"); - * - * // property (on prototype) - * result = Reflect.hasOwnMetadata("custom:annotation", C.prototype, "property"); - * - * // method (on constructor) - * result = Reflect.hasOwnMetadata("custom:annotation", C, "staticMethod"); - * - * // method (on prototype) - * result = Reflect.hasOwnMetadata("custom:annotation", C.prototype, "method"); - * - */ - function hasOwnMetadata(metadataKey, target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - return OrdinaryHasOwnMetadata(metadataKey, target, targetKey); - } - Reflect.hasOwnMetadata = hasOwnMetadata; - /** - * Gets the metadata value for the provided metadata key on the target object or its prototype chain. - * @param metadataKey A key used to store and retrieve metadata. - * @param target The target object on which the metadata is defined. - * @param targetKey (Optional) The property key for the target. - * @returns The metadata value for the metadata key if found; otherwise, `undefined`. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * result = Reflect.getMetadata("custom:annotation", C); - * - * // property (on constructor) - * result = Reflect.getMetadata("custom:annotation", C, "staticProperty"); - * - * // property (on prototype) - * result = Reflect.getMetadata("custom:annotation", C.prototype, "property"); - * - * // method (on constructor) - * result = Reflect.getMetadata("custom:annotation", C, "staticMethod"); - * - * // method (on prototype) - * result = Reflect.getMetadata("custom:annotation", C.prototype, "method"); - * - */ - function getMetadata(metadataKey, target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - return OrdinaryGetMetadata(metadataKey, target, targetKey); - } - Reflect.getMetadata = getMetadata; - /** - * Gets the metadata value for the provided metadata key on the target object. - * @param metadataKey A key used to store and retrieve metadata. - * @param target The target object on which the metadata is defined. - * @param targetKey (Optional) The property key for the target. - * @returns The metadata value for the metadata key if found; otherwise, `undefined`. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * result = Reflect.getOwnMetadata("custom:annotation", C); - * - * // property (on constructor) - * result = Reflect.getOwnMetadata("custom:annotation", C, "staticProperty"); - * - * // property (on prototype) - * result = Reflect.getOwnMetadata("custom:annotation", C.prototype, "property"); - * - * // method (on constructor) - * result = Reflect.getOwnMetadata("custom:annotation", C, "staticMethod"); - * - * // method (on prototype) - * result = Reflect.getOwnMetadata("custom:annotation", C.prototype, "method"); - * - */ - function getOwnMetadata(metadataKey, target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - return OrdinaryGetOwnMetadata(metadataKey, target, targetKey); - } - Reflect.getOwnMetadata = getOwnMetadata; - /** - * Gets the metadata keys defined on the target object or its prototype chain. - * @param target The target object on which the metadata is defined. - * @param targetKey (Optional) The property key for the target. - * @returns An array of unique metadata keys. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * result = Reflect.getMetadataKeys(C); - * - * // property (on constructor) - * result = Reflect.getMetadataKeys(C, "staticProperty"); - * - * // property (on prototype) - * result = Reflect.getMetadataKeys(C.prototype, "property"); - * - * // method (on constructor) - * result = Reflect.getMetadataKeys(C, "staticMethod"); - * - * // method (on prototype) - * result = Reflect.getMetadataKeys(C.prototype, "method"); - * - */ - function getMetadataKeys(target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - return OrdinaryMetadataKeys(target, targetKey); - } - Reflect.getMetadataKeys = getMetadataKeys; - /** - * Gets the unique metadata keys defined on the target object. - * @param target The target object on which the metadata is defined. - * @param targetKey (Optional) The property key for the target. - * @returns An array of unique metadata keys. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * result = Reflect.getOwnMetadataKeys(C); - * - * // property (on constructor) - * result = Reflect.getOwnMetadataKeys(C, "staticProperty"); - * - * // property (on prototype) - * result = Reflect.getOwnMetadataKeys(C.prototype, "property"); - * - * // method (on constructor) - * result = Reflect.getOwnMetadataKeys(C, "staticMethod"); - * - * // method (on prototype) - * result = Reflect.getOwnMetadataKeys(C.prototype, "method"); - * - */ - function getOwnMetadataKeys(target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - return OrdinaryOwnMetadataKeys(target, targetKey); - } - Reflect.getOwnMetadataKeys = getOwnMetadataKeys; - /** - * Deletes the metadata entry from the target object with the provided key. - * @param metadataKey A key used to store and retrieve metadata. - * @param target The target object on which the metadata is defined. - * @param targetKey (Optional) The property key for the target. - * @returns `true` if the metadata entry was found and deleted; otherwise, false. - * @example - * - * class C { - * // property declarations are not part of ES6, though they are valid in TypeScript: - * // static staticProperty; - * // property; - * - * constructor(p) { } - * static staticMethod(p) { } - * method(p) { } - * } - * - * // constructor - * result = Reflect.deleteMetadata("custom:annotation", C); - * - * // property (on constructor) - * result = Reflect.deleteMetadata("custom:annotation", C, "staticProperty"); - * - * // property (on prototype) - * result = Reflect.deleteMetadata("custom:annotation", C.prototype, "property"); - * - * // method (on constructor) - * result = Reflect.deleteMetadata("custom:annotation", C, "staticMethod"); - * - * // method (on prototype) - * result = Reflect.deleteMetadata("custom:annotation", C.prototype, "method"); - * - */ - function deleteMetadata(metadataKey, target, targetKey) { - if (!IsObject(target)) { - throw new TypeError(); - } - else if (!IsUndefined(targetKey)) { - targetKey = ToPropertyKey(targetKey); - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#deletemetadata-metadatakey-p- - var metadataMap = GetOrCreateMetadataMap(target, targetKey, false); - if (IsUndefined(metadataMap)) { - return false; - } - if (!metadataMap.delete(metadataKey)) { - return false; - } - if (metadataMap.size > 0) { - return true; - } - var targetMetadata = __Metadata__.get(target); - targetMetadata.delete(targetKey); - if (targetMetadata.size > 0) { - return true; - } - __Metadata__.delete(target); - return true; - } - Reflect.deleteMetadata = deleteMetadata; - function DecorateConstructor(decorators, target) { - for (var i = decorators.length - 1; i >= 0; --i) { - var decorator = decorators[i]; - var decorated = decorator(target); - if (!IsUndefined(decorated)) { - if (!IsConstructor(decorated)) { - throw new TypeError(); - } - target = decorated; - } - } - return target; - } - function DecoratePropertyWithDescriptor(decorators, target, propertyKey, descriptor) { - for (var i = decorators.length - 1; i >= 0; --i) { - var decorator = decorators[i]; - var decorated = decorator(target, propertyKey, descriptor); - if (!IsUndefined(decorated)) { - if (!IsObject(decorated)) { - throw new TypeError(); - } - descriptor = decorated; - } - } - return descriptor; - } - function DecoratePropertyWithoutDescriptor(decorators, target, propertyKey) { - for (var i = decorators.length - 1; i >= 0; --i) { - var decorator = decorators[i]; - decorator(target, propertyKey); - } - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#getorcreatemetadatamap--o-p-create- - function GetOrCreateMetadataMap(target, targetKey, create) { - var targetMetadata = __Metadata__.get(target); - if (!targetMetadata) { - if (!create) { - return undefined; - } - targetMetadata = new _Map(); - __Metadata__.set(target, targetMetadata); - } - var keyMetadata = targetMetadata.get(targetKey); - if (!keyMetadata) { - if (!create) { - return undefined; - } - keyMetadata = new _Map(); - targetMetadata.set(targetKey, keyMetadata); - } - return keyMetadata; - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasmetadata--metadatakey-o-p- - function OrdinaryHasMetadata(MetadataKey, O, P) { - var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); - if (hasOwn) { - return true; - } - var parent = GetPrototypeOf(O); - if (parent !== null) { - return OrdinaryHasMetadata(MetadataKey, parent, P); - } - return false; - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasownmetadata--metadatakey-o-p- - function OrdinaryHasOwnMetadata(MetadataKey, O, P) { - var metadataMap = GetOrCreateMetadataMap(O, P, false); - if (metadataMap === undefined) { - return false; - } - return Boolean(metadataMap.has(MetadataKey)); - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetmetadata--metadatakey-o-p- - function OrdinaryGetMetadata(MetadataKey, O, P) { - var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); - if (hasOwn) { - return OrdinaryGetOwnMetadata(MetadataKey, O, P); - } - var parent = GetPrototypeOf(O); - if (parent !== null) { - return OrdinaryGetMetadata(MetadataKey, parent, P); - } - return undefined; - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetownmetadata--metadatakey-o-p- - function OrdinaryGetOwnMetadata(MetadataKey, O, P) { - var metadataMap = GetOrCreateMetadataMap(O, P, false); - if (metadataMap === undefined) { - return undefined; - } - return metadataMap.get(MetadataKey); - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarydefineownmetadata--metadatakey-metadatavalue-o-p- - function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { - var metadataMap = GetOrCreateMetadataMap(O, P, true); - metadataMap.set(MetadataKey, MetadataValue); - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarymetadatakeys--o-p- - function OrdinaryMetadataKeys(O, P) { - var ownKeys = OrdinaryOwnMetadataKeys(O, P); - var parent = GetPrototypeOf(O); - if (parent === null) { - return ownKeys; - } - var parentKeys = OrdinaryMetadataKeys(parent, P); - if (parentKeys.length <= 0) { - return ownKeys; - } - if (ownKeys.length <= 0) { - return parentKeys; - } - var set = new _Set(); - var keys = []; - for (var _i = 0; _i < ownKeys.length; _i++) { - var key = ownKeys[_i]; - var hasKey = set.has(key); - if (!hasKey) { - set.add(key); - keys.push(key); - } - } - for (var _a = 0; _a < parentKeys.length; _a++) { - var key = parentKeys[_a]; - var hasKey = set.has(key); - if (!hasKey) { - set.add(key); - keys.push(key); - } - } - return keys; - } - // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryownmetadatakeys--o-p- - function OrdinaryOwnMetadataKeys(target, targetKey) { - var metadataMap = GetOrCreateMetadataMap(target, targetKey, false); - var keys = []; - if (metadataMap) { - metadataMap.forEach(function (_, key) { return keys.push(key); }); - } - return keys; - } - // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-undefined-type - function IsUndefined(x) { - return x === undefined; - } - // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray - function IsArray(x) { - return Array.isArray(x); - } - // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object-type - function IsObject(x) { - return typeof x === "object" ? x !== null : typeof x === "function"; - } - // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor - function IsConstructor(x) { - return typeof x === "function"; - } - // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-symbol-type - function IsSymbol(x) { - return typeof x === "symbol"; - } - // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey - function ToPropertyKey(value) { - if (IsSymbol(value)) { - return value; - } - return String(value); - } - function GetPrototypeOf(O) { - var proto = Object.getPrototypeOf(O); - if (typeof O !== "function" || O === functionPrototype) { - return proto; - } - // TypeScript doesn't set __proto__ in ES5, as it's non-standard. - // Try to determine the superclass constructor. Compatible implementations - // must either set __proto__ on a subclass constructor to the superclass constructor, - // or ensure each class has a valid `constructor` property on its prototype that - // points back to the constructor. - // If this is not the same as Function.[[Prototype]], then this is definately inherited. - // This is the case when in ES6 or when using __proto__ in a compatible browser. - if (proto !== functionPrototype) { - return proto; - } - // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage. - var prototype = O.prototype; - var prototypeProto = Object.getPrototypeOf(prototype); - if (prototypeProto == null || prototypeProto === Object.prototype) { - return proto; - } - // if the constructor was not a function, then we cannot determine the heritage. - var constructor = prototypeProto.constructor; - if (typeof constructor !== "function") { - return proto; - } - // if we have some kind of self-reference, then we cannot determine the heritage. - if (constructor === O) { - return proto; - } - // we have a pretty good guess at the heritage. - return constructor; - } - // naive Map shim - function CreateMapPolyfill() { - var cacheSentinel = {}; - function Map() { - this._keys = []; - this._values = []; - this._cache = cacheSentinel; - } - Map.prototype = { - get size() { - return this._keys.length; - }, - has: function (key) { - if (key === this._cache) { - return true; - } - if (this._find(key) >= 0) { - this._cache = key; - return true; - } - return false; - }, - get: function (key) { - var index = this._find(key); - if (index >= 0) { - this._cache = key; - return this._values[index]; - } - return undefined; - }, - set: function (key, value) { - this.delete(key); - this._keys.push(key); - this._values.push(value); - this._cache = key; - return this; - }, - delete: function (key) { - var index = this._find(key); - if (index >= 0) { - this._keys.splice(index, 1); - this._values.splice(index, 1); - this._cache = cacheSentinel; - return true; - } - return false; - }, - clear: function () { - this._keys.length = 0; - this._values.length = 0; - this._cache = cacheSentinel; - }, - forEach: function (callback, thisArg) { - var size = this.size; - for (var i = 0; i < size; ++i) { - var key = this._keys[i]; - var value = this._values[i]; - this._cache = key; - callback.call(this, value, key, this); - } - }, - _find: function (key) { - var keys = this._keys; - var size = keys.length; - for (var i = 0; i < size; ++i) { - if (keys[i] === key) { - return i; - } - } - return -1; - } - }; - return Map; - } - // naive Set shim - function CreateSetPolyfill() { - var cacheSentinel = {}; - function Set() { - this._map = new _Map(); - } - Set.prototype = { - get size() { - return this._map.length; - }, - has: function (value) { - return this._map.has(value); - }, - add: function (value) { - this._map.set(value, value); - return this; - }, - delete: function (value) { - return this._map.delete(value); - }, - clear: function () { - this._map.clear(); - }, - forEach: function (callback, thisArg) { - this._map.forEach(callback, thisArg); - } - }; - return Set; - } - // naive WeakMap shim - function CreateWeakMapPolyfill() { - var UUID_SIZE = 16; - var isNode = typeof global !== "undefined" && - typeof module === "object" && - typeof module.exports === "object" && - typeof require === "function"; - var nodeCrypto = isNode && require("crypto"); - var hasOwn = Object.prototype.hasOwnProperty; - var keys = {}; - var rootKey = CreateUniqueKey(); - function WeakMap() { - this._key = CreateUniqueKey(); - } - WeakMap.prototype = { - has: function (target) { - var table = GetOrCreateWeakMapTable(target, false); - if (table) { - return this._key in table; - } - return false; - }, - get: function (target) { - var table = GetOrCreateWeakMapTable(target, false); - if (table) { - return table[this._key]; - } - return undefined; - }, - set: function (target, value) { - var table = GetOrCreateWeakMapTable(target, true); - table[this._key] = value; - return this; - }, - delete: function (target) { - var table = GetOrCreateWeakMapTable(target, false); - if (table && this._key in table) { - return delete table[this._key]; - } - return false; - }, - clear: function () { - // NOTE: not a real clear, just makes the previous data unreachable - this._key = CreateUniqueKey(); - } - }; - function FillRandomBytes(buffer, size) { - for (var i = 0; i < size; ++i) { - buffer[i] = Math.random() * 255 | 0; - } - } - function GenRandomBytes(size) { - if (nodeCrypto) { - var data = nodeCrypto.randomBytes(size); - return data; - } - else if (typeof Uint8Array === "function") { - var data = new Uint8Array(size); - if (typeof crypto !== "undefined") { - crypto.getRandomValues(data); - } - else if (typeof msCrypto !== "undefined") { - msCrypto.getRandomValues(data); - } - else { - FillRandomBytes(data, size); - } - return data; - } - else { - var data = new Array(size); - FillRandomBytes(data, size); - return data; - } - } - function CreateUUID() { - var data = GenRandomBytes(UUID_SIZE); - // mark as random - RFC 4122 § 4.4 - data[6] = data[6] & 0x4f | 0x40; - data[8] = data[8] & 0xbf | 0x80; - var result = ""; - for (var offset = 0; offset < UUID_SIZE; ++offset) { - var byte = data[offset]; - if (offset === 4 || offset === 6 || offset === 8) { - result += "-"; - } - if (byte < 16) { - result += "0"; - } - result += byte.toString(16).toLowerCase(); - } - return result; - } - function CreateUniqueKey() { - var key; - do { - key = "@@WeakMap@@" + CreateUUID(); - } while (hasOwn.call(keys, key)); - keys[key] = true; - return key; - } - function GetOrCreateWeakMapTable(target, create) { - if (!hasOwn.call(target, rootKey)) { - if (!create) { - return undefined; - } - Object.defineProperty(target, rootKey, { value: Object.create(null) }); - } - return target[rootKey]; - } - return WeakMap; - } - // hook global Reflect - (function (__global) { - if (typeof __global.Reflect !== "undefined") { - if (__global.Reflect !== Reflect) { - for (var p in Reflect) { - __global.Reflect[p] = Reflect[p]; - } - } - } - else { - __global.Reflect = Reflect; - } - })(typeof window !== "undefined" ? window : - typeof WorkerGlobalScope !== "undefined" ? self : - typeof global !== "undefined" ? global : - Function("return this;")()); -})(Reflect || (Reflect = {})); -//# sourceMappingURLDisabled=Reflect.js.map -"format register"; -System.register("rx/dist/rx.all", [], true, function(require, exports, module) { - var global = System.global, - __define = global.define; - global.define = undefined; - ; - (function(undefined) { - var objectTypes = { - 'boolean': false, - 'function': true, - 'object': true, - 'number': false, - 'string': false, - 'undefined': false - }; - var root = (objectTypes[typeof window] && window) || this, - freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports, - freeModule = objectTypes[typeof module] && module && !module.nodeType && module, - moduleExports = freeModule && freeModule.exports === freeExports && freeExports, - freeGlobal = objectTypes[typeof global] && global; - if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) { - root = freeGlobal; - } - var Rx = { - internals: {}, - config: {Promise: root.Promise}, - helpers: {} - }; - var noop = Rx.helpers.noop = function() {}, - notDefined = Rx.helpers.notDefined = function(x) { - return typeof x === 'undefined'; - }, - isScheduler = Rx.helpers.isScheduler = function(x) { - return x instanceof Rx.Scheduler; - }, - identity = Rx.helpers.identity = function(x) { - return x; - }, - pluck = Rx.helpers.pluck = function(property) { - return function(x) { - return x[property]; - }; - }, - just = Rx.helpers.just = function(value) { - return function() { - return value; - }; - }, - defaultNow = Rx.helpers.defaultNow = Date.now, - defaultComparer = Rx.helpers.defaultComparer = function(x, y) { - return isEqual(x, y); - }, - defaultSubComparer = Rx.helpers.defaultSubComparer = function(x, y) { - return x > y ? 1 : (x < y ? -1 : 0); - }, - defaultKeySerializer = Rx.helpers.defaultKeySerializer = function(x) { - return x.toString(); - }, - defaultError = Rx.helpers.defaultError = function(err) { - throw err; - }, - isPromise = Rx.helpers.isPromise = function(p) { - return !!p && typeof p.then === 'function'; - }, - asArray = Rx.helpers.asArray = function() { - return Array.prototype.slice.call(arguments); - }, - not = Rx.helpers.not = function(a) { - return !a; - }, - isFunction = Rx.helpers.isFunction = (function() { - var isFn = function(value) { - return typeof value == 'function' || false; - }; - if (isFn(/x/)) { - isFn = function(value) { - return typeof value == 'function' && toString.call(value) == '[object Function]'; - }; - } - return isFn; - }()); - function cloneArray(arr) { - for (var a = [], - i = 0, - len = arr.length; i < len; i++) { - a.push(arr[i]); - } - return a; - } - Rx.config.longStackSupport = false; - var hasStacks = false; - try { - throw new Error(); - } catch (e) { - hasStacks = !!e.stack; - } - var rStartingLine = captureLine(), - rFileName; - var STACK_JUMP_SEPARATOR = "From previous event:"; - function makeStackTraceLong(error, observable) { - if (hasStacks && observable.stack && typeof error === "object" && error !== null && error.stack && error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1) { - var stacks = []; - for (var o = observable; !!o; o = o.source) { - if (o.stack) { - stacks.unshift(o.stack); - } - } - stacks.unshift(error.stack); - var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n"); - error.stack = filterStackString(concatedStacks); - } - } - function filterStackString(stackString) { - var lines = stackString.split("\n"), - desiredLines = []; - for (var i = 0, - len = lines.length; i < len; i++) { - var line = lines[i]; - if (!isInternalFrame(line) && !isNodeFrame(line) && line) { - desiredLines.push(line); - } - } - return desiredLines.join("\n"); - } - function isInternalFrame(stackLine) { - var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine); - if (!fileNameAndLineNumber) { - return false; - } - var fileName = fileNameAndLineNumber[0], - lineNumber = fileNameAndLineNumber[1]; - return fileName === rFileName && lineNumber >= rStartingLine && lineNumber <= rEndingLine; - } - function isNodeFrame(stackLine) { - return stackLine.indexOf("(module.js:") !== -1 || stackLine.indexOf("(node.js:") !== -1; - } - function captureLine() { - if (!hasStacks) { - return ; - } - try { - throw new Error(); - } catch (e) { - var lines = e.stack.split("\n"); - var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2]; - var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine); - if (!fileNameAndLineNumber) { - return ; - } - rFileName = fileNameAndLineNumber[0]; - return fileNameAndLineNumber[1]; - } - } - function getFileNameAndLineNumber(stackLine) { - var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine); - if (attempt1) { - return [attempt1[1], Number(attempt1[2])]; - } - var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine); - if (attempt2) { - return [attempt2[1], Number(attempt2[2])]; - } - var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine); - if (attempt3) { - return [attempt3[1], Number(attempt3[2])]; - } - } - var EmptyError = Rx.EmptyError = function() { - this.message = 'Sequence contains no elements.'; - Error.call(this); - }; - EmptyError.prototype = Error.prototype; - var ObjectDisposedError = Rx.ObjectDisposedError = function() { - this.message = 'Object has been disposed'; - Error.call(this); - }; - ObjectDisposedError.prototype = Error.prototype; - var ArgumentOutOfRangeError = Rx.ArgumentOutOfRangeError = function() { - this.message = 'Argument out of range'; - Error.call(this); - }; - ArgumentOutOfRangeError.prototype = Error.prototype; - var NotSupportedError = Rx.NotSupportedError = function(message) { - this.message = message || 'This operation is not supported'; - Error.call(this); - }; - NotSupportedError.prototype = Error.prototype; - var NotImplementedError = Rx.NotImplementedError = function(message) { - this.message = message || 'This operation is not implemented'; - Error.call(this); - }; - NotImplementedError.prototype = Error.prototype; - var notImplemented = Rx.helpers.notImplemented = function() { - throw new NotImplementedError(); - }; - var notSupported = Rx.helpers.notSupported = function() { - throw new NotSupportedError(); - }; - var $iterator$ = (typeof Symbol === 'function' && Symbol.iterator) || '_es6shim_iterator_'; - if (root.Set && typeof new root.Set()['@@iterator'] === 'function') { - $iterator$ = '@@iterator'; - } - var doneEnumerator = Rx.doneEnumerator = { - done: true, - value: undefined - }; - var isIterable = Rx.helpers.isIterable = function(o) { - return o[$iterator$] !== undefined; - }; - var isArrayLike = Rx.helpers.isArrayLike = function(o) { - return o && o.length !== undefined; - }; - Rx.helpers.iterator = $iterator$; - var bindCallback = Rx.internals.bindCallback = function(func, thisArg, argCount) { - if (typeof thisArg === 'undefined') { - return func; - } - switch (argCount) { - case 0: - return function() { - return func.call(thisArg); - }; - case 1: - return function(arg) { - return func.call(thisArg, arg); - }; - case 2: - return function(value, index) { - return func.call(thisArg, value, index); - }; - case 3: - return function(value, index, collection) { - return func.call(thisArg, value, index, collection); - }; - } - return function() { - return func.apply(thisArg, arguments); - }; - }; - var dontEnums = ['toString', 'toLocaleString', 'valueOf', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'constructor'], - dontEnumsLength = dontEnums.length; - var argsClass = '[object Arguments]', - arrayClass = '[object Array]', - boolClass = '[object Boolean]', - dateClass = '[object Date]', - errorClass = '[object Error]', - funcClass = '[object Function]', - numberClass = '[object Number]', - objectClass = '[object Object]', - regexpClass = '[object RegExp]', - stringClass = '[object String]'; - var toString = Object.prototype.toString, - hasOwnProperty = Object.prototype.hasOwnProperty, - supportsArgsClass = toString.call(arguments) == argsClass, - supportNodeClass, - errorProto = Error.prototype, - objectProto = Object.prototype, - stringProto = String.prototype, - propertyIsEnumerable = objectProto.propertyIsEnumerable; - try { - supportNodeClass = !(toString.call(document) == objectClass && !({'toString': 0} + '')); - } catch (e) { - supportNodeClass = true; - } - var nonEnumProps = {}; - nonEnumProps[arrayClass] = nonEnumProps[dateClass] = nonEnumProps[numberClass] = { - 'constructor': true, - 'toLocaleString': true, - 'toString': true, - 'valueOf': true - }; - nonEnumProps[boolClass] = nonEnumProps[stringClass] = { - 'constructor': true, - 'toString': true, - 'valueOf': true - }; - nonEnumProps[errorClass] = nonEnumProps[funcClass] = nonEnumProps[regexpClass] = { - 'constructor': true, - 'toString': true - }; - nonEnumProps[objectClass] = {'constructor': true}; - var support = {}; - (function() { - var ctor = function() { - this.x = 1; - }, - props = []; - ctor.prototype = { - 'valueOf': 1, - 'y': 1 - }; - for (var key in new ctor) { - props.push(key); - } - for (key in arguments) {} - support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name'); - support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype'); - support.nonEnumArgs = key != 0; - support.nonEnumShadows = !/valueOf/.test(props); - }(1)); - var isObject = Rx.internals.isObject = function(value) { - var type = typeof value; - return value && (type == 'function' || type == 'object') || false; - }; - function keysIn(object) { - var result = []; - if (!isObject(object)) { - return result; - } - if (support.nonEnumArgs && object.length && isArguments(object)) { - object = slice.call(object); - } - var skipProto = support.enumPrototypes && typeof object == 'function', - skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error); - for (var key in object) { - if (!(skipProto && key == 'prototype') && !(skipErrorProps && (key == 'message' || key == 'name'))) { - result.push(key); - } - } - if (support.nonEnumShadows && object !== objectProto) { - var ctor = object.constructor, - index = -1, - length = dontEnumsLength; - if (object === (ctor && ctor.prototype)) { - var className = object === stringProto ? stringClass : object === errorProto ? errorClass : toString.call(object), - nonEnum = nonEnumProps[className]; - } - while (++index < length) { - key = dontEnums[index]; - if (!(nonEnum && nonEnum[key]) && hasOwnProperty.call(object, key)) { - result.push(key); - } - } - } - return result; - } - function internalFor(object, callback, keysFunc) { - var index = -1, - props = keysFunc(object), - length = props.length; - while (++index < length) { - var key = props[index]; - if (callback(object[key], key, object) === false) { - break; - } - } - return object; - } - function internalForIn(object, callback) { - return internalFor(object, callback, keysIn); - } - function isNode(value) { - return typeof value.toString != 'function' && typeof(value + '') == 'string'; - } - var isArguments = function(value) { - return (value && typeof value == 'object') ? toString.call(value) == argsClass : false; - }; - if (!supportsArgsClass) { - isArguments = function(value) { - return (value && typeof value == 'object') ? hasOwnProperty.call(value, 'callee') : false; - }; - } - var isEqual = Rx.internals.isEqual = function(x, y) { - return deepEquals(x, y, [], []); - }; - function deepEquals(a, b, stackA, stackB) { - if (a === b) { - return a !== 0 || (1 / a == 1 / b); - } - var type = typeof a, - otherType = typeof b; - if (a === a && (a == null || b == null || (type != 'function' && type != 'object' && otherType != 'function' && otherType != 'object'))) { - return false; - } - var className = toString.call(a), - otherClass = toString.call(b); - if (className == argsClass) { - className = objectClass; - } - if (otherClass == argsClass) { - otherClass = objectClass; - } - if (className != otherClass) { - return false; - } - switch (className) { - case boolClass: - case dateClass: - return +a == +b; - case numberClass: - return (a != +a) ? b != +b : (a == 0 ? (1 / a == 1 / b) : a == +b); - case regexpClass: - case stringClass: - return a == String(b); - } - var isArr = className == arrayClass; - if (!isArr) { - if (className != objectClass || (!support.nodeClass && (isNode(a) || isNode(b)))) { - return false; - } - var ctorA = !support.argsObject && isArguments(a) ? Object : a.constructor, - ctorB = !support.argsObject && isArguments(b) ? Object : b.constructor; - if (ctorA != ctorB && !(hasOwnProperty.call(a, 'constructor') && hasOwnProperty.call(b, 'constructor')) && !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) && ('constructor' in a && 'constructor' in b)) { - return false; - } - } - var initedStack = !stackA; - stackA || (stackA = []); - stackB || (stackB = []); - var length = stackA.length; - while (length--) { - if (stackA[length] == a) { - return stackB[length] == b; - } - } - var size = 0; - var result = true; - stackA.push(a); - stackB.push(b); - if (isArr) { - length = a.length; - size = b.length; - result = size == length; - if (result) { - while (size--) { - var index = length, - value = b[size]; - if (!(result = deepEquals(a[size], value, stackA, stackB))) { - break; - } - } - } - } else { - internalForIn(b, function(value, key, b) { - if (hasOwnProperty.call(b, key)) { - size++; - return (result = hasOwnProperty.call(a, key) && deepEquals(a[key], value, stackA, stackB)); - } - }); - if (result) { - internalForIn(a, function(value, key, a) { - if (hasOwnProperty.call(a, key)) { - return (result = --size > -1); - } - }); - } - } - stackA.pop(); - stackB.pop(); - return result; - } - var hasProp = {}.hasOwnProperty, - slice = Array.prototype.slice; - var inherits = this.inherits = Rx.internals.inherits = function(child, parent) { - function __() { - this.constructor = child; - } - __.prototype = parent.prototype; - child.prototype = new __(); - }; - var addProperties = Rx.internals.addProperties = function(obj) { - for (var sources = [], - i = 1, - len = arguments.length; i < len; i++) { - sources.push(arguments[i]); - } - for (var idx = 0, - ln = sources.length; idx < ln; idx++) { - var source = sources[idx]; - for (var prop in source) { - obj[prop] = source[prop]; - } - } - }; - var addRef = Rx.internals.addRef = function(xs, r) { - return new AnonymousObservable(function(observer) { - return new CompositeDisposable(r.getDisposable(), xs.subscribe(observer)); - }); - }; - function arrayInitialize(count, factory) { - var a = new Array(count); - for (var i = 0; i < count; i++) { - a[i] = factory(); - } - return a; - } - var errorObj = {e: {}}; - var tryCatchTarget; - function tryCatcher() { - try { - return tryCatchTarget.apply(this, arguments); - } catch (e) { - errorObj.e = e; - return errorObj; - } - } - function tryCatch(fn) { - if (!isFunction(fn)) { - throw new TypeError('fn must be a function'); - } - tryCatchTarget = fn; - return tryCatcher; - } - function thrower(e) { - throw e; - } - function IndexedItem(id, value) { - this.id = id; - this.value = value; - } - IndexedItem.prototype.compareTo = function(other) { - var c = this.value.compareTo(other.value); - c === 0 && (c = this.id - other.id); - return c; - }; - var PriorityQueue = Rx.internals.PriorityQueue = function(capacity) { - this.items = new Array(capacity); - this.length = 0; - }; - var priorityProto = PriorityQueue.prototype; - priorityProto.isHigherPriority = function(left, right) { - return this.items[left].compareTo(this.items[right]) < 0; - }; - priorityProto.percolate = function(index) { - if (index >= this.length || index < 0) { - return ; - } - var parent = index - 1 >> 1; - if (parent < 0 || parent === index) { - return ; - } - if (this.isHigherPriority(index, parent)) { - var temp = this.items[index]; - this.items[index] = this.items[parent]; - this.items[parent] = temp; - this.percolate(parent); - } - }; - priorityProto.heapify = function(index) { - +index || (index = 0); - if (index >= this.length || index < 0) { - return ; - } - var left = 2 * index + 1, - right = 2 * index + 2, - first = index; - if (left < this.length && this.isHigherPriority(left, first)) { - first = left; - } - if (right < this.length && this.isHigherPriority(right, first)) { - first = right; - } - if (first !== index) { - var temp = this.items[index]; - this.items[index] = this.items[first]; - this.items[first] = temp; - this.heapify(first); - } - }; - priorityProto.peek = function() { - return this.items[0].value; - }; - priorityProto.removeAt = function(index) { - this.items[index] = this.items[--this.length]; - this.items[this.length] = undefined; - this.heapify(); - }; - priorityProto.dequeue = function() { - var result = this.peek(); - this.removeAt(0); - return result; - }; - priorityProto.enqueue = function(item) { - var index = this.length++; - this.items[index] = new IndexedItem(PriorityQueue.count++, item); - this.percolate(index); - }; - priorityProto.remove = function(item) { - for (var i = 0; i < this.length; i++) { - if (this.items[i].value === item) { - this.removeAt(i); - return true; - } - } - return false; - }; - PriorityQueue.count = 0; - var CompositeDisposable = Rx.CompositeDisposable = function() { - var args = [], - i, - len; - if (Array.isArray(arguments[0])) { - args = arguments[0]; - len = args.length; - } else { - len = arguments.length; - args = new Array(len); - for (i = 0; i < len; i++) { - args[i] = arguments[i]; - } - } - for (i = 0; i < len; i++) { - if (!isDisposable(args[i])) { - throw new TypeError('Not a disposable'); - } - } - this.disposables = args; - this.isDisposed = false; - this.length = args.length; - }; - var CompositeDisposablePrototype = CompositeDisposable.prototype; - CompositeDisposablePrototype.add = function(item) { - if (this.isDisposed) { - item.dispose(); - } else { - this.disposables.push(item); - this.length++; - } - }; - CompositeDisposablePrototype.remove = function(item) { - var shouldDispose = false; - if (!this.isDisposed) { - var idx = this.disposables.indexOf(item); - if (idx !== -1) { - shouldDispose = true; - this.disposables.splice(idx, 1); - this.length--; - item.dispose(); - } - } - return shouldDispose; - }; - CompositeDisposablePrototype.dispose = function() { - if (!this.isDisposed) { - this.isDisposed = true; - var len = this.disposables.length, - currentDisposables = new Array(len); - for (var i = 0; i < len; i++) { - currentDisposables[i] = this.disposables[i]; - } - this.disposables = []; - this.length = 0; - for (i = 0; i < len; i++) { - currentDisposables[i].dispose(); - } - } - }; - var Disposable = Rx.Disposable = function(action) { - this.isDisposed = false; - this.action = action || noop; - }; - Disposable.prototype.dispose = function() { - if (!this.isDisposed) { - this.action(); - this.isDisposed = true; - } - }; - var disposableCreate = Disposable.create = function(action) { - return new Disposable(action); - }; - var disposableEmpty = Disposable.empty = {dispose: noop}; - var isDisposable = Disposable.isDisposable = function(d) { - return d && isFunction(d.dispose); - }; - var checkDisposed = Disposable.checkDisposed = function(disposable) { - if (disposable.isDisposed) { - throw new ObjectDisposedError(); - } - }; - var SingleAssignmentDisposable = Rx.SingleAssignmentDisposable = (function() { - function BooleanDisposable() { - this.isDisposed = false; - this.current = null; - } - var booleanDisposablePrototype = BooleanDisposable.prototype; - booleanDisposablePrototype.getDisposable = function() { - return this.current; - }; - booleanDisposablePrototype.setDisposable = function(value) { - var shouldDispose = this.isDisposed; - if (!shouldDispose) { - var old = this.current; - this.current = value; - } - old && old.dispose(); - shouldDispose && value && value.dispose(); - }; - booleanDisposablePrototype.dispose = function() { - if (!this.isDisposed) { - this.isDisposed = true; - var old = this.current; - this.current = null; - } - old && old.dispose(); - }; - return BooleanDisposable; - }()); - var SerialDisposable = Rx.SerialDisposable = SingleAssignmentDisposable; - var RefCountDisposable = Rx.RefCountDisposable = (function() { - function InnerDisposable(disposable) { - this.disposable = disposable; - this.disposable.count++; - this.isInnerDisposed = false; - } - InnerDisposable.prototype.dispose = function() { - if (!this.disposable.isDisposed && !this.isInnerDisposed) { - this.isInnerDisposed = true; - this.disposable.count--; - if (this.disposable.count === 0 && this.disposable.isPrimaryDisposed) { - this.disposable.isDisposed = true; - this.disposable.underlyingDisposable.dispose(); - } - } - }; - function RefCountDisposable(disposable) { - this.underlyingDisposable = disposable; - this.isDisposed = false; - this.isPrimaryDisposed = false; - this.count = 0; - } - RefCountDisposable.prototype.dispose = function() { - if (!this.isDisposed && !this.isPrimaryDisposed) { - this.isPrimaryDisposed = true; - if (this.count === 0) { - this.isDisposed = true; - this.underlyingDisposable.dispose(); - } - } - }; - RefCountDisposable.prototype.getDisposable = function() { - return this.isDisposed ? disposableEmpty : new InnerDisposable(this); - }; - return RefCountDisposable; - })(); - function ScheduledDisposable(scheduler, disposable) { - this.scheduler = scheduler; - this.disposable = disposable; - this.isDisposed = false; - } - function scheduleItem(s, self) { - if (!self.isDisposed) { - self.isDisposed = true; - self.disposable.dispose(); - } - } - ScheduledDisposable.prototype.dispose = function() { - this.scheduler.scheduleWithState(this, scheduleItem); - }; - var ScheduledItem = Rx.internals.ScheduledItem = function(scheduler, state, action, dueTime, comparer) { - this.scheduler = scheduler; - this.state = state; - this.action = action; - this.dueTime = dueTime; - this.comparer = comparer || defaultSubComparer; - this.disposable = new SingleAssignmentDisposable(); - }; - ScheduledItem.prototype.invoke = function() { - this.disposable.setDisposable(this.invokeCore()); - }; - ScheduledItem.prototype.compareTo = function(other) { - return this.comparer(this.dueTime, other.dueTime); - }; - ScheduledItem.prototype.isCancelled = function() { - return this.disposable.isDisposed; - }; - ScheduledItem.prototype.invokeCore = function() { - return this.action(this.scheduler, this.state); - }; - var Scheduler = Rx.Scheduler = (function() { - function Scheduler(now, schedule, scheduleRelative, scheduleAbsolute) { - this.now = now; - this._schedule = schedule; - this._scheduleRelative = scheduleRelative; - this._scheduleAbsolute = scheduleAbsolute; - } - function invokeAction(scheduler, action) { - action(); - return disposableEmpty; - } - var schedulerProto = Scheduler.prototype; - schedulerProto.schedule = function(action) { - return this._schedule(action, invokeAction); - }; - schedulerProto.scheduleWithState = function(state, action) { - return this._schedule(state, action); - }; - schedulerProto.scheduleWithRelative = function(dueTime, action) { - return this._scheduleRelative(action, dueTime, invokeAction); - }; - schedulerProto.scheduleWithRelativeAndState = function(state, dueTime, action) { - return this._scheduleRelative(state, dueTime, action); - }; - schedulerProto.scheduleWithAbsolute = function(dueTime, action) { - return this._scheduleAbsolute(action, dueTime, invokeAction); - }; - schedulerProto.scheduleWithAbsoluteAndState = function(state, dueTime, action) { - return this._scheduleAbsolute(state, dueTime, action); - }; - Scheduler.now = defaultNow; - Scheduler.normalize = function(timeSpan) { - timeSpan < 0 && (timeSpan = 0); - return timeSpan; - }; - return Scheduler; - }()); - var normalizeTime = Scheduler.normalize; - (function(schedulerProto) { - function invokeRecImmediate(scheduler, pair) { - var state = pair[0], - action = pair[1], - group = new CompositeDisposable(); - function recursiveAction(state1) { - action(state1, function(state2) { - var isAdded = false, - isDone = false, - d = scheduler.scheduleWithState(state2, function(scheduler1, state3) { - if (isAdded) { - group.remove(d); - } else { - isDone = true; - } - recursiveAction(state3); - return disposableEmpty; - }); - if (!isDone) { - group.add(d); - isAdded = true; - } - }); - } - recursiveAction(state); - return group; - } - function invokeRecDate(scheduler, pair, method) { - var state = pair[0], - action = pair[1], - group = new CompositeDisposable(); - function recursiveAction(state1) { - action(state1, function(state2, dueTime1) { - var isAdded = false, - isDone = false, - d = scheduler[method](state2, dueTime1, function(scheduler1, state3) { - if (isAdded) { - group.remove(d); - } else { - isDone = true; - } - recursiveAction(state3); - return disposableEmpty; - }); - if (!isDone) { - group.add(d); - isAdded = true; - } - }); - } - ; - recursiveAction(state); - return group; - } - function scheduleInnerRecursive(action, self) { - action(function(dt) { - self(action, dt); - }); - } - schedulerProto.scheduleRecursive = function(action) { - return this.scheduleRecursiveWithState(action, function(_action, self) { - _action(function() { - self(_action); - }); - }); - }; - schedulerProto.scheduleRecursiveWithState = function(state, action) { - return this.scheduleWithState([state, action], invokeRecImmediate); - }; - schedulerProto.scheduleRecursiveWithRelative = function(dueTime, action) { - return this.scheduleRecursiveWithRelativeAndState(action, dueTime, scheduleInnerRecursive); - }; - schedulerProto.scheduleRecursiveWithRelativeAndState = function(state, dueTime, action) { - return this._scheduleRelative([state, action], dueTime, function(s, p) { - return invokeRecDate(s, p, 'scheduleWithRelativeAndState'); - }); - }; - schedulerProto.scheduleRecursiveWithAbsolute = function(dueTime, action) { - return this.scheduleRecursiveWithAbsoluteAndState(action, dueTime, scheduleInnerRecursive); - }; - schedulerProto.scheduleRecursiveWithAbsoluteAndState = function(state, dueTime, action) { - return this._scheduleAbsolute([state, action], dueTime, function(s, p) { - return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState'); - }); - }; - }(Scheduler.prototype)); - (function(schedulerProto) { - Scheduler.prototype.schedulePeriodic = function(period, action) { - return this.schedulePeriodicWithState(null, period, action); - }; - Scheduler.prototype.schedulePeriodicWithState = function(state, period, action) { - if (typeof root.setInterval === 'undefined') { - throw new NotSupportedError(); - } - period = normalizeTime(period); - var s = state, - id = root.setInterval(function() { - s = action(s); - }, period); - return disposableCreate(function() { - root.clearInterval(id); - }); - }; - }(Scheduler.prototype)); - (function(schedulerProto) { - schedulerProto.catchError = schedulerProto['catch'] = function(handler) { - return new CatchScheduler(this, handler); - }; - }(Scheduler.prototype)); - var SchedulePeriodicRecursive = Rx.internals.SchedulePeriodicRecursive = (function() { - function tick(command, recurse) { - recurse(0, this._period); - try { - this._state = this._action(this._state); - } catch (e) { - this._cancel.dispose(); - throw e; - } - } - function SchedulePeriodicRecursive(scheduler, state, period, action) { - this._scheduler = scheduler; - this._state = state; - this._period = period; - this._action = action; - } - SchedulePeriodicRecursive.prototype.start = function() { - var d = new SingleAssignmentDisposable(); - this._cancel = d; - d.setDisposable(this._scheduler.scheduleRecursiveWithRelativeAndState(0, this._period, tick.bind(this))); - return d; - }; - return SchedulePeriodicRecursive; - }()); - var immediateScheduler = Scheduler.immediate = (function() { - function scheduleNow(state, action) { - return action(this, state); - } - return new Scheduler(defaultNow, scheduleNow, notSupported, notSupported); - }()); - var currentThreadScheduler = Scheduler.currentThread = (function() { - var queue; - function runTrampoline() { - while (queue.length > 0) { - var item = queue.dequeue(); - !item.isCancelled() && item.invoke(); - } - } - function scheduleNow(state, action) { - var si = new ScheduledItem(this, state, action, this.now()); - if (!queue) { - queue = new PriorityQueue(4); - queue.enqueue(si); - var result = tryCatch(runTrampoline)(); - queue = null; - if (result === errorObj) { - return thrower(result.e); - } - } else { - queue.enqueue(si); - } - return si.disposable; - } - var currentScheduler = new Scheduler(defaultNow, scheduleNow, notSupported, notSupported); - currentScheduler.scheduleRequired = function() { - return !queue; - }; - return currentScheduler; - }()); - var scheduleMethod, - clearMethod; - var localTimer = (function() { - var localSetTimeout, - localClearTimeout = noop; - if (!!root.WScript) { - localSetTimeout = function(fn, time) { - root.WScript.Sleep(time); - fn(); - }; - } else if (!!root.setTimeout) { - localSetTimeout = root.setTimeout; - localClearTimeout = root.clearTimeout; - } else { - throw new NotSupportedError(); - } - return { - setTimeout: localSetTimeout, - clearTimeout: localClearTimeout - }; - }()); - var localSetTimeout = localTimer.setTimeout, - localClearTimeout = localTimer.clearTimeout; - (function() { - var nextHandle = 1, - tasksByHandle = {}, - currentlyRunning = false; - clearMethod = function(handle) { - delete tasksByHandle[handle]; - }; - function runTask(handle) { - if (currentlyRunning) { - localSetTimeout(function() { - runTask(handle); - }, 0); - } else { - var task = tasksByHandle[handle]; - if (task) { - currentlyRunning = true; - var result = tryCatch(task)(); - clearMethod(handle); - currentlyRunning = false; - if (result === errorObj) { - return thrower(result.e); - } - } - } - } - var reNative = RegExp('^' + String(toString).replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/toString| for [^\]]+/g, '.*?') + '$'); - var setImmediate = typeof(setImmediate = freeGlobal && moduleExports && freeGlobal.setImmediate) == 'function' && !reNative.test(setImmediate) && setImmediate; - function postMessageSupported() { - if (!root.postMessage || root.importScripts) { - return false; - } - var isAsync = false, - oldHandler = root.onmessage; - root.onmessage = function() { - isAsync = true; - }; - root.postMessage('', '*'); - root.onmessage = oldHandler; - return isAsync; - } - if (isFunction(setImmediate)) { - scheduleMethod = function(action) { - var id = nextHandle++; - tasksByHandle[id] = action; - setImmediate(function() { - runTask(id); - }); - return id; - }; - } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') { - scheduleMethod = function(action) { - var id = nextHandle++; - tasksByHandle[id] = action; - process.nextTick(function() { - runTask(id); - }); - return id; - }; - } else if (postMessageSupported()) { - var MSG_PREFIX = 'ms.rx.schedule' + Math.random(); - function onGlobalPostMessage(event) { - if (typeof event.data === 'string' && event.data.substring(0, MSG_PREFIX.length) === MSG_PREFIX) { - runTask(event.data.substring(MSG_PREFIX.length)); - } - } - if (root.addEventListener) { - root.addEventListener('message', onGlobalPostMessage, false); - } else { - root.attachEvent('onmessage', onGlobalPostMessage, false); - } - scheduleMethod = function(action) { - var id = nextHandle++; - tasksByHandle[id] = action; - root.postMessage(MSG_PREFIX + currentId, '*'); - return id; - }; - } else if (!!root.MessageChannel) { - var channel = new root.MessageChannel(); - channel.port1.onmessage = function(e) { - runTask(e.data); - }; - scheduleMethod = function(action) { - var id = nextHandle++; - tasksByHandle[id] = action; - channel.port2.postMessage(id); - return id; - }; - } else if ('document' in root && 'onreadystatechange' in root.document.createElement('script')) { - scheduleMethod = function(action) { - var scriptElement = root.document.createElement('script'); - var id = nextHandle++; - tasksByHandle[id] = action; - scriptElement.onreadystatechange = function() { - runTask(id); - scriptElement.onreadystatechange = null; - scriptElement.parentNode.removeChild(scriptElement); - scriptElement = null; - }; - root.document.documentElement.appendChild(scriptElement); - return id; - }; - } else { - scheduleMethod = function(action) { - var id = nextHandle++; - tasksByHandle[id] = action; - localSetTimeout(function() { - runTask(id); - }, 0); - return id; - }; - } - }()); - var timeoutScheduler = Scheduler.timeout = Scheduler.default = (function() { - function scheduleNow(state, action) { - var scheduler = this, - disposable = new SingleAssignmentDisposable(); - var id = scheduleMethod(function() { - if (!disposable.isDisposed) { - disposable.setDisposable(action(scheduler, state)); - } - }); - return new CompositeDisposable(disposable, disposableCreate(function() { - clearMethod(id); - })); - } - function scheduleRelative(state, dueTime, action) { - var scheduler = this, - dt = Scheduler.normalize(dueTime); - if (dt === 0) { - return scheduler.scheduleWithState(state, action); - } - var disposable = new SingleAssignmentDisposable(); - var id = localSetTimeout(function() { - if (!disposable.isDisposed) { - disposable.setDisposable(action(scheduler, state)); - } - }, dt); - return new CompositeDisposable(disposable, disposableCreate(function() { - localClearTimeout(id); - })); - } - function scheduleAbsolute(state, dueTime, action) { - return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action); - } - return new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute); - })(); - var CatchScheduler = (function(__super__) { - function scheduleNow(state, action) { - return this._scheduler.scheduleWithState(state, this._wrap(action)); - } - function scheduleRelative(state, dueTime, action) { - return this._scheduler.scheduleWithRelativeAndState(state, dueTime, this._wrap(action)); - } - function scheduleAbsolute(state, dueTime, action) { - return this._scheduler.scheduleWithAbsoluteAndState(state, dueTime, this._wrap(action)); - } - inherits(CatchScheduler, __super__); - function CatchScheduler(scheduler, handler) { - this._scheduler = scheduler; - this._handler = handler; - this._recursiveOriginal = null; - this._recursiveWrapper = null; - __super__.call(this, this._scheduler.now.bind(this._scheduler), scheduleNow, scheduleRelative, scheduleAbsolute); - } - CatchScheduler.prototype._clone = function(scheduler) { - return new CatchScheduler(scheduler, this._handler); - }; - CatchScheduler.prototype._wrap = function(action) { - var parent = this; - return function(self, state) { - try { - return action(parent._getRecursiveWrapper(self), state); - } catch (e) { - if (!parent._handler(e)) { - throw e; - } - return disposableEmpty; - } - }; - }; - CatchScheduler.prototype._getRecursiveWrapper = function(scheduler) { - if (this._recursiveOriginal !== scheduler) { - this._recursiveOriginal = scheduler; - var wrapper = this._clone(scheduler); - wrapper._recursiveOriginal = scheduler; - wrapper._recursiveWrapper = wrapper; - this._recursiveWrapper = wrapper; - } - return this._recursiveWrapper; - }; - CatchScheduler.prototype.schedulePeriodicWithState = function(state, period, action) { - var self = this, - failed = false, - d = new SingleAssignmentDisposable(); - d.setDisposable(this._scheduler.schedulePeriodicWithState(state, period, function(state1) { - if (failed) { - return null; - } - try { - return action(state1); - } catch (e) { - failed = true; - if (!self._handler(e)) { - throw e; - } - d.dispose(); - return null; - } - })); - return d; - }; - return CatchScheduler; - }(Scheduler)); - var Notification = Rx.Notification = (function() { - function Notification(kind, value, exception, accept, acceptObservable, toString) { - this.kind = kind; - this.value = value; - this.exception = exception; - this._accept = accept; - this._acceptObservable = acceptObservable; - this.toString = toString; - } - Notification.prototype.accept = function(observerOrOnNext, onError, onCompleted) { - return observerOrOnNext && typeof observerOrOnNext === 'object' ? this._acceptObservable(observerOrOnNext) : this._accept(observerOrOnNext, onError, onCompleted); - }; - Notification.prototype.toObservable = function(scheduler) { - var self = this; - isScheduler(scheduler) || (scheduler = immediateScheduler); - return new AnonymousObservable(function(observer) { - return scheduler.scheduleWithState(self, function(_, notification) { - notification._acceptObservable(observer); - notification.kind === 'N' && observer.onCompleted(); - }); - }); - }; - return Notification; - })(); - var notificationCreateOnNext = Notification.createOnNext = (function() { - function _accept(onNext) { - return onNext(this.value); - } - function _acceptObservable(observer) { - return observer.onNext(this.value); - } - function toString() { - return 'OnNext(' + this.value + ')'; - } - return function(value) { - return new Notification('N', value, null, _accept, _acceptObservable, toString); - }; - }()); - var notificationCreateOnError = Notification.createOnError = (function() { - function _accept(onNext, onError) { - return onError(this.exception); - } - function _acceptObservable(observer) { - return observer.onError(this.exception); - } - function toString() { - return 'OnError(' + this.exception + ')'; - } - return function(e) { - return new Notification('E', null, e, _accept, _acceptObservable, toString); - }; - }()); - var notificationCreateOnCompleted = Notification.createOnCompleted = (function() { - function _accept(onNext, onError, onCompleted) { - return onCompleted(); - } - function _acceptObservable(observer) { - return observer.onCompleted(); - } - function toString() { - return 'OnCompleted()'; - } - return function() { - return new Notification('C', null, null, _accept, _acceptObservable, toString); - }; - }()); - var Enumerator = Rx.internals.Enumerator = function(next) { - this._next = next; - }; - Enumerator.prototype.next = function() { - return this._next(); - }; - Enumerator.prototype[$iterator$] = function() { - return this; - }; - var Enumerable = Rx.internals.Enumerable = function(iterator) { - this._iterator = iterator; - }; - Enumerable.prototype[$iterator$] = function() { - return this._iterator(); - }; - Enumerable.prototype.concat = function() { - var sources = this; - return new AnonymousObservable(function(o) { - var e = sources[$iterator$](); - var isDisposed, - subscription = new SerialDisposable(); - var cancelable = immediateScheduler.scheduleRecursive(function(self) { - if (isDisposed) { - return ; - } - try { - var currentItem = e.next(); - } catch (ex) { - return o.onError(ex); - } - if (currentItem.done) { - return o.onCompleted(); - } - var currentValue = currentItem.value; - isPromise(currentValue) && (currentValue = observableFromPromise(currentValue)); - var d = new SingleAssignmentDisposable(); - subscription.setDisposable(d); - d.setDisposable(currentValue.subscribe(function(x) { - o.onNext(x); - }, function(err) { - o.onError(err); - }, self)); - }); - return new CompositeDisposable(subscription, cancelable, disposableCreate(function() { - isDisposed = true; - })); - }); - }; - Enumerable.prototype.catchError = function() { - var sources = this; - return new AnonymousObservable(function(o) { - var e = sources[$iterator$](); - var isDisposed, - subscription = new SerialDisposable(); - var cancelable = immediateScheduler.scheduleRecursiveWithState(null, function(lastException, self) { - if (isDisposed) { - return ; - } - try { - var currentItem = e.next(); - } catch (ex) { - return observer.onError(ex); - } - if (currentItem.done) { - if (lastException !== null) { - o.onError(lastException); - } else { - o.onCompleted(); - } - return ; - } - var currentValue = currentItem.value; - isPromise(currentValue) && (currentValue = observableFromPromise(currentValue)); - var d = new SingleAssignmentDisposable(); - subscription.setDisposable(d); - d.setDisposable(currentValue.subscribe(function(x) { - o.onNext(x); - }, self, function() { - o.onCompleted(); - })); - }); - return new CompositeDisposable(subscription, cancelable, disposableCreate(function() { - isDisposed = true; - })); - }); - }; - Enumerable.prototype.catchErrorWhen = function(notificationHandler) { - var sources = this; - return new AnonymousObservable(function(o) { - var exceptions = new Subject(), - notifier = new Subject(), - handled = notificationHandler(exceptions), - notificationDisposable = handled.subscribe(notifier); - var e = sources[$iterator$](); - var isDisposed, - lastException, - subscription = new SerialDisposable(); - var cancelable = immediateScheduler.scheduleRecursive(function(self) { - if (isDisposed) { - return ; - } - try { - var currentItem = e.next(); - } catch (ex) { - return o.onError(ex); - } - if (currentItem.done) { - if (lastException) { - o.onError(lastException); - } else { - o.onCompleted(); - } - return ; - } - var currentValue = currentItem.value; - isPromise(currentValue) && (currentValue = observableFromPromise(currentValue)); - var outer = new SingleAssignmentDisposable(); - var inner = new SingleAssignmentDisposable(); - subscription.setDisposable(new CompositeDisposable(inner, outer)); - outer.setDisposable(currentValue.subscribe(function(x) { - o.onNext(x); - }, function(exn) { - inner.setDisposable(notifier.subscribe(self, function(ex) { - o.onError(ex); - }, function() { - o.onCompleted(); - })); - exceptions.onNext(exn); - }, function() { - o.onCompleted(); - })); - }); - return new CompositeDisposable(notificationDisposable, subscription, cancelable, disposableCreate(function() { - isDisposed = true; - })); - }); - }; - var enumerableRepeat = Enumerable.repeat = function(value, repeatCount) { - if (repeatCount == null) { - repeatCount = -1; - } - return new Enumerable(function() { - var left = repeatCount; - return new Enumerator(function() { - if (left === 0) { - return doneEnumerator; - } - if (left > 0) { - left--; - } - return { - done: false, - value: value - }; - }); - }); - }; - var enumerableOf = Enumerable.of = function(source, selector, thisArg) { - if (selector) { - var selectorFn = bindCallback(selector, thisArg, 3); - } - return new Enumerable(function() { - var index = -1; - return new Enumerator(function() { - return ++index < source.length ? { - done: false, - value: !selector ? source[index] : selectorFn(source[index], index, source) - } : doneEnumerator; - }); - }); - }; - var Observer = Rx.Observer = function() {}; - Observer.prototype.toNotifier = function() { - var observer = this; - return function(n) { - return n.accept(observer); - }; - }; - Observer.prototype.asObserver = function() { - return new AnonymousObserver(this.onNext.bind(this), this.onError.bind(this), this.onCompleted.bind(this)); - }; - Observer.prototype.checked = function() { - return new CheckedObserver(this); - }; - var observerCreate = Observer.create = function(onNext, onError, onCompleted) { - onNext || (onNext = noop); - onError || (onError = defaultError); - onCompleted || (onCompleted = noop); - return new AnonymousObserver(onNext, onError, onCompleted); - }; - Observer.fromNotifier = function(handler, thisArg) { - return new AnonymousObserver(function(x) { - return handler.call(thisArg, notificationCreateOnNext(x)); - }, function(e) { - return handler.call(thisArg, notificationCreateOnError(e)); - }, function() { - return handler.call(thisArg, notificationCreateOnCompleted()); - }); - }; - Observer.prototype.notifyOn = function(scheduler) { - return new ObserveOnObserver(scheduler, this); - }; - Observer.prototype.makeSafe = function(disposable) { - return new AnonymousSafeObserver(this._onNext, this._onError, this._onCompleted, disposable); - }; - var AbstractObserver = Rx.internals.AbstractObserver = (function(__super__) { - inherits(AbstractObserver, __super__); - function AbstractObserver() { - this.isStopped = false; - __super__.call(this); - } - AbstractObserver.prototype.next = notImplemented; - AbstractObserver.prototype.error = notImplemented; - AbstractObserver.prototype.completed = notImplemented; - AbstractObserver.prototype.onNext = function(value) { - if (!this.isStopped) { - this.next(value); - } - }; - AbstractObserver.prototype.onError = function(error) { - if (!this.isStopped) { - this.isStopped = true; - this.error(error); - } - }; - AbstractObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - this.isStopped = true; - this.completed(); - } - }; - AbstractObserver.prototype.dispose = function() { - this.isStopped = true; - }; - AbstractObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.error(e); - return true; - } - return false; - }; - return AbstractObserver; - }(Observer)); - var AnonymousObserver = Rx.AnonymousObserver = (function(__super__) { - inherits(AnonymousObserver, __super__); - function AnonymousObserver(onNext, onError, onCompleted) { - __super__.call(this); - this._onNext = onNext; - this._onError = onError; - this._onCompleted = onCompleted; - } - AnonymousObserver.prototype.next = function(value) { - this._onNext(value); - }; - AnonymousObserver.prototype.error = function(error) { - this._onError(error); - }; - AnonymousObserver.prototype.completed = function() { - this._onCompleted(); - }; - return AnonymousObserver; - }(AbstractObserver)); - var CheckedObserver = (function(__super__) { - inherits(CheckedObserver, __super__); - function CheckedObserver(observer) { - __super__.call(this); - this._observer = observer; - this._state = 0; - } - var CheckedObserverPrototype = CheckedObserver.prototype; - CheckedObserverPrototype.onNext = function(value) { - this.checkAccess(); - var res = tryCatch(this._observer.onNext).call(this._observer, value); - this._state = 0; - res === errorObj && thrower(res.e); - }; - CheckedObserverPrototype.onError = function(err) { - this.checkAccess(); - var res = tryCatch(this._observer.onError).call(this._observer, err); - this._state = 2; - res === errorObj && thrower(res.e); - }; - CheckedObserverPrototype.onCompleted = function() { - this.checkAccess(); - var res = tryCatch(this._observer.onCompleted).call(this._observer); - this._state = 2; - res === errorObj && thrower(res.e); - }; - CheckedObserverPrototype.checkAccess = function() { - if (this._state === 1) { - throw new Error('Re-entrancy detected'); - } - if (this._state === 2) { - throw new Error('Observer completed'); - } - if (this._state === 0) { - this._state = 1; - } - }; - return CheckedObserver; - }(Observer)); - var ScheduledObserver = Rx.internals.ScheduledObserver = (function(__super__) { - inherits(ScheduledObserver, __super__); - function ScheduledObserver(scheduler, observer) { - __super__.call(this); - this.scheduler = scheduler; - this.observer = observer; - this.isAcquired = false; - this.hasFaulted = false; - this.queue = []; - this.disposable = new SerialDisposable(); - } - ScheduledObserver.prototype.next = function(value) { - var self = this; - this.queue.push(function() { - self.observer.onNext(value); - }); - }; - ScheduledObserver.prototype.error = function(e) { - var self = this; - this.queue.push(function() { - self.observer.onError(e); - }); - }; - ScheduledObserver.prototype.completed = function() { - var self = this; - this.queue.push(function() { - self.observer.onCompleted(); - }); - }; - ScheduledObserver.prototype.ensureActive = function() { - var isOwner = false, - parent = this; - if (!this.hasFaulted && this.queue.length > 0) { - isOwner = !this.isAcquired; - this.isAcquired = true; - } - if (isOwner) { - this.disposable.setDisposable(this.scheduler.scheduleRecursive(function(self) { - var work; - if (parent.queue.length > 0) { - work = parent.queue.shift(); - } else { - parent.isAcquired = false; - return ; - } - try { - work(); - } catch (ex) { - parent.queue = []; - parent.hasFaulted = true; - throw ex; - } - self(); - })); - } - }; - ScheduledObserver.prototype.dispose = function() { - __super__.prototype.dispose.call(this); - this.disposable.dispose(); - }; - return ScheduledObserver; - }(AbstractObserver)); - var ObserveOnObserver = (function(__super__) { - inherits(ObserveOnObserver, __super__); - function ObserveOnObserver(scheduler, observer, cancel) { - __super__.call(this, scheduler, observer); - this._cancel = cancel; - } - ObserveOnObserver.prototype.next = function(value) { - __super__.prototype.next.call(this, value); - this.ensureActive(); - }; - ObserveOnObserver.prototype.error = function(e) { - __super__.prototype.error.call(this, e); - this.ensureActive(); - }; - ObserveOnObserver.prototype.completed = function() { - __super__.prototype.completed.call(this); - this.ensureActive(); - }; - ObserveOnObserver.prototype.dispose = function() { - __super__.prototype.dispose.call(this); - this._cancel && this._cancel.dispose(); - this._cancel = null; - }; - return ObserveOnObserver; - })(ScheduledObserver); - var observableProto; - var Observable = Rx.Observable = (function() { - function Observable(subscribe) { - if (Rx.config.longStackSupport && hasStacks) { - try { - throw new Error(); - } catch (e) { - this.stack = e.stack.substring(e.stack.indexOf("\n") + 1); - } - var self = this; - this._subscribe = function(observer) { - var oldOnError = observer.onError.bind(observer); - observer.onError = function(err) { - makeStackTraceLong(err, self); - oldOnError(err); - }; - return subscribe.call(self, observer); - }; - } else { - this._subscribe = subscribe; - } - } - observableProto = Observable.prototype; - observableProto.subscribe = observableProto.forEach = function(observerOrOnNext, onError, onCompleted) { - return this._subscribe(typeof observerOrOnNext === 'object' ? observerOrOnNext : observerCreate(observerOrOnNext, onError, onCompleted)); - }; - observableProto.subscribeOnNext = function(onNext, thisArg) { - return this._subscribe(observerCreate(typeof thisArg !== 'undefined' ? function(x) { - onNext.call(thisArg, x); - } : onNext)); - }; - observableProto.subscribeOnError = function(onError, thisArg) { - return this._subscribe(observerCreate(null, typeof thisArg !== 'undefined' ? function(e) { - onError.call(thisArg, e); - } : onError)); - }; - observableProto.subscribeOnCompleted = function(onCompleted, thisArg) { - return this._subscribe(observerCreate(null, null, typeof thisArg !== 'undefined' ? function() { - onCompleted.call(thisArg); - } : onCompleted)); - }; - return Observable; - })(); - var ObservableBase = Rx.ObservableBase = (function(__super__) { - inherits(ObservableBase, __super__); - function fixSubscriber(subscriber) { - return subscriber && isFunction(subscriber.dispose) ? subscriber : isFunction(subscriber) ? disposableCreate(subscriber) : disposableEmpty; - } - function setDisposable(s, state) { - var ado = state[0], - self = state[1]; - var sub = tryCatch(self.subscribeCore).call(self, ado); - if (sub === errorObj) { - if (!ado.fail(errorObj.e)) { - return thrower(errorObj.e); - } - } - ado.setDisposable(fixSubscriber(sub)); - } - function subscribe(observer) { - var ado = new AutoDetachObserver(observer), - state = [ado, this]; - if (currentThreadScheduler.scheduleRequired()) { - currentThreadScheduler.scheduleWithState(state, setDisposable); - } else { - setDisposable(null, state); - } - return ado; - } - function ObservableBase() { - __super__.call(this, subscribe); - } - ObservableBase.prototype.subscribeCore = notImplemented; - return ObservableBase; - }(Observable)); - observableProto.observeOn = function(scheduler) { - var source = this; - return new AnonymousObservable(function(observer) { - return source.subscribe(new ObserveOnObserver(scheduler, observer)); - }, source); - }; - observableProto.subscribeOn = function(scheduler) { - var source = this; - return new AnonymousObservable(function(observer) { - var m = new SingleAssignmentDisposable(), - d = new SerialDisposable(); - d.setDisposable(m); - m.setDisposable(scheduler.schedule(function() { - d.setDisposable(new ScheduledDisposable(scheduler, source.subscribe(observer))); - })); - return d; - }, source); - }; - var observableFromPromise = Observable.fromPromise = function(promise) { - return observableDefer(function() { - var subject = new Rx.AsyncSubject(); - promise.then(function(value) { - subject.onNext(value); - subject.onCompleted(); - }, subject.onError.bind(subject)); - return subject; - }); - }; - observableProto.toPromise = function(promiseCtor) { - promiseCtor || (promiseCtor = Rx.config.Promise); - if (!promiseCtor) { - throw new NotSupportedError('Promise type not provided nor in Rx.config.Promise'); - } - var source = this; - return new promiseCtor(function(resolve, reject) { - var value, - hasValue = false; - source.subscribe(function(v) { - value = v; - hasValue = true; - }, reject, function() { - hasValue && resolve(value); - }); - }); - }; - var ToArrayObservable = (function(__super__) { - inherits(ToArrayObservable, __super__); - function ToArrayObservable(source) { - this.source = source; - __super__.call(this); - } - ToArrayObservable.prototype.subscribeCore = function(observer) { - return this.source.subscribe(new ToArrayObserver(observer)); - }; - return ToArrayObservable; - }(ObservableBase)); - function ToArrayObserver(observer) { - this.observer = observer; - this.a = []; - this.isStopped = false; - } - ToArrayObserver.prototype.onNext = function(x) { - if (!this.isStopped) { - this.a.push(x); - } - }; - ToArrayObserver.prototype.onError = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onError(e); - } - }; - ToArrayObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onNext(this.a); - this.observer.onCompleted(); - } - }; - ToArrayObserver.prototype.dispose = function() { - this.isStopped = true; - }; - ToArrayObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onError(e); - return true; - } - return false; - }; - observableProto.toArray = function() { - return new ToArrayObservable(this); - }; - Observable.create = Observable.createWithDisposable = function(subscribe, parent) { - return new AnonymousObservable(subscribe, parent); - }; - var observableDefer = Observable.defer = function(observableFactory) { - return new AnonymousObservable(function(observer) { - var result; - try { - result = observableFactory(); - } catch (e) { - return observableThrow(e).subscribe(observer); - } - isPromise(result) && (result = observableFromPromise(result)); - return result.subscribe(observer); - }); - }; - var observableEmpty = Observable.empty = function(scheduler) { - isScheduler(scheduler) || (scheduler = immediateScheduler); - return new AnonymousObservable(function(observer) { - return scheduler.scheduleWithState(null, function() { - observer.onCompleted(); - }); - }); - }; - var FromObservable = (function(__super__) { - inherits(FromObservable, __super__); - function FromObservable(iterable, mapper, scheduler) { - this.iterable = iterable; - this.mapper = mapper; - this.scheduler = scheduler; - __super__.call(this); - } - FromObservable.prototype.subscribeCore = function(observer) { - var sink = new FromSink(observer, this); - return sink.run(); - }; - return FromObservable; - }(ObservableBase)); - var FromSink = (function() { - function FromSink(observer, parent) { - this.observer = observer; - this.parent = parent; - } - FromSink.prototype.run = function() { - var list = Object(this.parent.iterable), - it = getIterable(list), - observer = this.observer, - mapper = this.parent.mapper; - function loopRecursive(i, recurse) { - try { - var next = it.next(); - } catch (e) { - return observer.onError(e); - } - if (next.done) { - return observer.onCompleted(); - } - var result = next.value; - if (mapper) { - try { - result = mapper(result, i); - } catch (e) { - return observer.onError(e); - } - } - observer.onNext(result); - recurse(i + 1); - } - return this.parent.scheduler.scheduleRecursiveWithState(0, loopRecursive); - }; - return FromSink; - }()); - var maxSafeInteger = Math.pow(2, 53) - 1; - function StringIterable(str) { - this._s = s; - } - StringIterable.prototype[$iterator$] = function() { - return new StringIterator(this._s); - }; - function StringIterator(str) { - this._s = s; - this._l = s.length; - this._i = 0; - } - StringIterator.prototype[$iterator$] = function() { - return this; - }; - StringIterator.prototype.next = function() { - return this._i < this._l ? { - done: false, - value: this._s.charAt(this._i++) - } : doneEnumerator; - }; - function ArrayIterable(a) { - this._a = a; - } - ArrayIterable.prototype[$iterator$] = function() { - return new ArrayIterator(this._a); - }; - function ArrayIterator(a) { - this._a = a; - this._l = toLength(a); - this._i = 0; - } - ArrayIterator.prototype[$iterator$] = function() { - return this; - }; - ArrayIterator.prototype.next = function() { - return this._i < this._l ? { - done: false, - value: this._a[this._i++] - } : doneEnumerator; - }; - function numberIsFinite(value) { - return typeof value === 'number' && root.isFinite(value); - } - function isNan(n) { - return n !== n; - } - function getIterable(o) { - var i = o[$iterator$], - it; - if (!i && typeof o === 'string') { - it = new StringIterable(o); - return it[$iterator$](); - } - if (!i && o.length !== undefined) { - it = new ArrayIterable(o); - return it[$iterator$](); - } - if (!i) { - throw new TypeError('Object is not iterable'); - } - return o[$iterator$](); - } - function sign(value) { - var number = +value; - if (number === 0) { - return number; - } - if (isNaN(number)) { - return number; - } - return number < 0 ? -1 : 1; - } - function toLength(o) { - var len = +o.length; - if (isNaN(len)) { - return 0; - } - if (len === 0 || !numberIsFinite(len)) { - return len; - } - len = sign(len) * Math.floor(Math.abs(len)); - if (len <= 0) { - return 0; - } - if (len > maxSafeInteger) { - return maxSafeInteger; - } - return len; - } - var observableFrom = Observable.from = function(iterable, mapFn, thisArg, scheduler) { - if (iterable == null) { - throw new Error('iterable cannot be null.'); - } - if (mapFn && !isFunction(mapFn)) { - throw new Error('mapFn when provided must be a function'); - } - if (mapFn) { - var mapper = bindCallback(mapFn, thisArg, 2); - } - isScheduler(scheduler) || (scheduler = currentThreadScheduler); - return new FromObservable(iterable, mapper, scheduler); - }; - var FromArrayObservable = (function(__super__) { - inherits(FromArrayObservable, __super__); - function FromArrayObservable(args, scheduler) { - this.args = args; - this.scheduler = scheduler; - __super__.call(this); - } - FromArrayObservable.prototype.subscribeCore = function(observer) { - var sink = new FromArraySink(observer, this); - return sink.run(); - }; - return FromArrayObservable; - }(ObservableBase)); - function FromArraySink(observer, parent) { - this.observer = observer; - this.parent = parent; - } - FromArraySink.prototype.run = function() { - var observer = this.observer, - args = this.parent.args, - len = args.length; - function loopRecursive(i, recurse) { - if (i < len) { - observer.onNext(args[i]); - recurse(i + 1); - } else { - observer.onCompleted(); - } - } - return this.parent.scheduler.scheduleRecursiveWithState(0, loopRecursive); - }; - var observableFromArray = Observable.fromArray = function(array, scheduler) { - isScheduler(scheduler) || (scheduler = currentThreadScheduler); - return new FromArrayObservable(array, scheduler); - }; - Observable.generate = function(initialState, condition, iterate, resultSelector, scheduler) { - isScheduler(scheduler) || (scheduler = currentThreadScheduler); - return new AnonymousObservable(function(o) { - var first = true; - return scheduler.scheduleRecursiveWithState(initialState, function(state, self) { - var hasResult, - result; - try { - if (first) { - first = false; - } else { - state = iterate(state); - } - hasResult = condition(state); - hasResult && (result = resultSelector(state)); - } catch (e) { - return o.onError(e); - } - if (hasResult) { - o.onNext(result); - self(state); - } else { - o.onCompleted(); - } - }); - }); - }; - function observableOf(scheduler, array) { - isScheduler(scheduler) || (scheduler = currentThreadScheduler); - return new FromArrayObservable(array, scheduler); - } - Observable.of = function() { - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - return new FromArrayObservable(args, currentThreadScheduler); - }; - Observable.ofWithScheduler = function(scheduler) { - var len = arguments.length, - args = new Array(len - 1); - for (var i = 1; i < len; i++) { - args[i - 1] = arguments[i]; - } - return new FromArrayObservable(args, scheduler); - }; - Observable.ofArrayChanges = function(array) { - if (!Array.isArray(array)) { - throw new TypeError('Array.observe only accepts arrays.'); - } - if (typeof Array.observe !== 'function' && typeof Array.unobserve !== 'function') { - throw new TypeError('Array.observe is not supported on your platform'); - } - return new AnonymousObservable(function(observer) { - function observerFn(changes) { - for (var i = 0, - len = changes.length; i < len; i++) { - observer.onNext(changes[i]); - } - } - Array.observe(array, observerFn); - return function() { - Array.unobserve(array, observerFn); - }; - }); - }; - Observable.ofObjectChanges = function(obj) { - if (obj == null) { - throw new TypeError('object must not be null or undefined.'); - } - if (typeof Object.observe !== 'function' && typeof Object.unobserve !== 'function') { - throw new TypeError('Array.observe is not supported on your platform'); - } - return new AnonymousObservable(function(observer) { - function observerFn(changes) { - for (var i = 0, - len = changes.length; i < len; i++) { - observer.onNext(changes[i]); - } - } - Object.observe(obj, observerFn); - return function() { - Object.unobserve(obj, observerFn); - }; - }); - }; - var observableNever = Observable.never = function() { - return new AnonymousObservable(function() { - return disposableEmpty; - }); - }; - Observable.pairs = function(obj, scheduler) { - scheduler || (scheduler = Rx.Scheduler.currentThread); - return new AnonymousObservable(function(observer) { - var keys = Object.keys(obj), - len = keys.length; - return scheduler.scheduleRecursiveWithState(0, function(idx, self) { - if (idx < len) { - var key = keys[idx]; - observer.onNext([key, obj[key]]); - self(idx + 1); - } else { - observer.onCompleted(); - } - }); - }); - }; - var RangeObservable = (function(__super__) { - inherits(RangeObservable, __super__); - function RangeObservable(start, count, scheduler) { - this.start = start; - this.count = count; - this.scheduler = scheduler; - __super__.call(this); - } - RangeObservable.prototype.subscribeCore = function(observer) { - var sink = new RangeSink(observer, this); - return sink.run(); - }; - return RangeObservable; - }(ObservableBase)); - var RangeSink = (function() { - function RangeSink(observer, parent) { - this.observer = observer; - this.parent = parent; - } - RangeSink.prototype.run = function() { - var start = this.parent.start, - count = this.parent.count, - observer = this.observer; - function loopRecursive(i, recurse) { - if (i < count) { - observer.onNext(start + i); - recurse(i + 1); - } else { - observer.onCompleted(); - } - } - return this.parent.scheduler.scheduleRecursiveWithState(0, loopRecursive); - }; - return RangeSink; - }()); - Observable.range = function(start, count, scheduler) { - isScheduler(scheduler) || (scheduler = currentThreadScheduler); - return new RangeObservable(start, count, scheduler); - }; - Observable.repeat = function(value, repeatCount, scheduler) { - isScheduler(scheduler) || (scheduler = currentThreadScheduler); - return observableReturn(value, scheduler).repeat(repeatCount == null ? -1 : repeatCount); - }; - var observableReturn = Observable['return'] = Observable.just = Observable.returnValue = function(value, scheduler) { - isScheduler(scheduler) || (scheduler = immediateScheduler); - return new AnonymousObservable(function(o) { - return scheduler.scheduleWithState(value, function(_, v) { - o.onNext(v); - o.onCompleted(); - }); - }); - }; - var observableThrow = Observable['throw'] = Observable.throwError = function(error, scheduler) { - isScheduler(scheduler) || (scheduler = immediateScheduler); - return new AnonymousObservable(function(observer) { - return scheduler.schedule(function() { - observer.onError(error); - }); - }); - }; - Observable.throwException = function() { - return Observable.throwError.apply(null, arguments); - }; - Observable.using = function(resourceFactory, observableFactory) { - return new AnonymousObservable(function(observer) { - var disposable = disposableEmpty, - resource, - source; - try { - resource = resourceFactory(); - resource && (disposable = resource); - source = observableFactory(resource); - } catch (exception) { - return new CompositeDisposable(observableThrow(exception).subscribe(observer), disposable); - } - return new CompositeDisposable(source.subscribe(observer), disposable); - }); - }; - observableProto.amb = function(rightSource) { - var leftSource = this; - return new AnonymousObservable(function(observer) { - var choice, - leftChoice = 'L', - rightChoice = 'R', - leftSubscription = new SingleAssignmentDisposable(), - rightSubscription = new SingleAssignmentDisposable(); - isPromise(rightSource) && (rightSource = observableFromPromise(rightSource)); - function choiceL() { - if (!choice) { - choice = leftChoice; - rightSubscription.dispose(); - } - } - function choiceR() { - if (!choice) { - choice = rightChoice; - leftSubscription.dispose(); - } - } - leftSubscription.setDisposable(leftSource.subscribe(function(left) { - choiceL(); - if (choice === leftChoice) { - observer.onNext(left); - } - }, function(err) { - choiceL(); - if (choice === leftChoice) { - observer.onError(err); - } - }, function() { - choiceL(); - if (choice === leftChoice) { - observer.onCompleted(); - } - })); - rightSubscription.setDisposable(rightSource.subscribe(function(right) { - choiceR(); - if (choice === rightChoice) { - observer.onNext(right); - } - }, function(err) { - choiceR(); - if (choice === rightChoice) { - observer.onError(err); - } - }, function() { - choiceR(); - if (choice === rightChoice) { - observer.onCompleted(); - } - })); - return new CompositeDisposable(leftSubscription, rightSubscription); - }); - }; - Observable.amb = function() { - var acc = observableNever(), - items = []; - if (Array.isArray(arguments[0])) { - items = arguments[0]; - } else { - for (var i = 0, - len = arguments.length; i < len; i++) { - items.push(arguments[i]); - } - } - function func(previous, current) { - return previous.amb(current); - } - for (var i = 0, - len = items.length; i < len; i++) { - acc = func(acc, items[i]); - } - return acc; - }; - function observableCatchHandler(source, handler) { - return new AnonymousObservable(function(o) { - var d1 = new SingleAssignmentDisposable(), - subscription = new SerialDisposable(); - subscription.setDisposable(d1); - d1.setDisposable(source.subscribe(function(x) { - o.onNext(x); - }, function(e) { - try { - var result = handler(e); - } catch (ex) { - return o.onError(ex); - } - isPromise(result) && (result = observableFromPromise(result)); - var d = new SingleAssignmentDisposable(); - subscription.setDisposable(d); - d.setDisposable(result.subscribe(o)); - }, function(x) { - o.onCompleted(x); - })); - return subscription; - }, source); - } - observableProto['catch'] = observableProto.catchError = observableProto.catchException = function(handlerOrSecond) { - return typeof handlerOrSecond === 'function' ? observableCatchHandler(this, handlerOrSecond) : observableCatch([this, handlerOrSecond]); - }; - var observableCatch = Observable.catchError = Observable['catch'] = Observable.catchException = function() { - var items = []; - if (Array.isArray(arguments[0])) { - items = arguments[0]; - } else { - for (var i = 0, - len = arguments.length; i < len; i++) { - items.push(arguments[i]); - } - } - return enumerableOf(items).catchError(); - }; - observableProto.combineLatest = function() { - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - if (Array.isArray(args[0])) { - args[0].unshift(this); - } else { - args.unshift(this); - } - return combineLatest.apply(this, args); - }; - var combineLatest = Observable.combineLatest = function() { - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - var resultSelector = args.pop(); - Array.isArray(args[0]) && (args = args[0]); - return new AnonymousObservable(function(o) { - var n = args.length, - falseFactory = function() { - return false; - }, - hasValue = arrayInitialize(n, falseFactory), - hasValueAll = false, - isDone = arrayInitialize(n, falseFactory), - values = new Array(n); - function next(i) { - hasValue[i] = true; - if (hasValueAll || (hasValueAll = hasValue.every(identity))) { - try { - var res = resultSelector.apply(null, values); - } catch (e) { - return o.onError(e); - } - o.onNext(res); - } else if (isDone.filter(function(x, j) { - return j !== i; - }).every(identity)) { - o.onCompleted(); - } - } - function done(i) { - isDone[i] = true; - isDone.every(identity) && o.onCompleted(); - } - var subscriptions = new Array(n); - for (var idx = 0; idx < n; idx++) { - (function(i) { - var source = args[i], - sad = new SingleAssignmentDisposable(); - isPromise(source) && (source = observableFromPromise(source)); - sad.setDisposable(source.subscribe(function(x) { - values[i] = x; - next(i); - }, function(e) { - o.onError(e); - }, function() { - done(i); - })); - subscriptions[i] = sad; - }(idx)); - } - return new CompositeDisposable(subscriptions); - }, this); - }; - observableProto.concat = function() { - for (var args = [], - i = 0, - len = arguments.length; i < len; i++) { - args.push(arguments[i]); - } - args.unshift(this); - return observableConcat.apply(null, args); - }; - var observableConcat = Observable.concat = function() { - var args; - if (Array.isArray(arguments[0])) { - args = arguments[0]; - } else { - args = new Array(arguments.length); - for (var i = 0, - len = arguments.length; i < len; i++) { - args[i] = arguments[i]; - } - } - return enumerableOf(args).concat(); - }; - observableProto.concatAll = observableProto.concatObservable = function() { - return this.merge(1); - }; - var MergeObservable = (function(__super__) { - inherits(MergeObservable, __super__); - function MergeObservable(source, maxConcurrent) { - this.source = source; - this.maxConcurrent = maxConcurrent; - __super__.call(this); - } - MergeObservable.prototype.subscribeCore = function(observer) { - var g = new CompositeDisposable(); - g.add(this.source.subscribe(new MergeObserver(observer, this.maxConcurrent, g))); - return g; - }; - return MergeObservable; - }(ObservableBase)); - var MergeObserver = (function() { - function MergeObserver(o, max, g) { - this.o = o; - this.max = max; - this.g = g; - this.done = false; - this.q = []; - this.activeCount = 0; - this.isStopped = false; - } - MergeObserver.prototype.handleSubscribe = function(xs) { - var sad = new SingleAssignmentDisposable(); - this.g.add(sad); - isPromise(xs) && (xs = observableFromPromise(xs)); - sad.setDisposable(xs.subscribe(new InnerObserver(this, sad))); - }; - MergeObserver.prototype.onNext = function(innerSource) { - if (this.isStopped) { - return ; - } - if (this.activeCount < this.max) { - this.activeCount++; - this.handleSubscribe(innerSource); - } else { - this.q.push(innerSource); - } - }; - MergeObserver.prototype.onError = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.o.onError(e); - } - }; - MergeObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - this.isStopped = true; - this.done = true; - this.activeCount === 0 && this.o.onCompleted(); - } - }; - MergeObserver.prototype.dispose = function() { - this.isStopped = true; - }; - MergeObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.o.onError(e); - return true; - } - return false; - }; - function InnerObserver(parent, sad) { - this.parent = parent; - this.sad = sad; - this.isStopped = false; - } - InnerObserver.prototype.onNext = function(x) { - if (!this.isStopped) { - this.parent.o.onNext(x); - } - }; - InnerObserver.prototype.onError = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.parent.o.onError(e); - } - }; - InnerObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - this.isStopped = true; - var parent = this.parent; - parent.g.remove(this.sad); - if (parent.q.length > 0) { - parent.handleSubscribe(parent.q.shift()); - } else { - parent.activeCount--; - parent.done && parent.activeCount === 0 && parent.o.onCompleted(); - } - } - }; - InnerObserver.prototype.dispose = function() { - this.isStopped = true; - }; - InnerObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.parent.o.onError(e); - return true; - } - return false; - }; - return MergeObserver; - }()); - observableProto.merge = function(maxConcurrentOrOther) { - return typeof maxConcurrentOrOther !== 'number' ? observableMerge(this, maxConcurrentOrOther) : new MergeObservable(this, maxConcurrentOrOther); - }; - var observableMerge = Observable.merge = function() { - var scheduler, - sources = [], - i, - len = arguments.length; - if (!arguments[0]) { - scheduler = immediateScheduler; - for (i = 1; i < len; i++) { - sources.push(arguments[i]); - } - } else if (isScheduler(arguments[0])) { - scheduler = arguments[0]; - for (i = 1; i < len; i++) { - sources.push(arguments[i]); - } - } else { - scheduler = immediateScheduler; - for (i = 0; i < len; i++) { - sources.push(arguments[i]); - } - } - if (Array.isArray(sources[0])) { - sources = sources[0]; - } - return observableOf(scheduler, sources).mergeAll(); - }; - var MergeAllObservable = (function(__super__) { - inherits(MergeAllObservable, __super__); - function MergeAllObservable(source) { - this.source = source; - __super__.call(this); - } - MergeAllObservable.prototype.subscribeCore = function(observer) { - var g = new CompositeDisposable(), - m = new SingleAssignmentDisposable(); - g.add(m); - m.setDisposable(this.source.subscribe(new MergeAllObserver(observer, g))); - return g; - }; - return MergeAllObservable; - }(ObservableBase)); - var MergeAllObserver = (function() { - function MergeAllObserver(o, g) { - this.o = o; - this.g = g; - this.isStopped = false; - this.done = false; - } - MergeAllObserver.prototype.onNext = function(innerSource) { - if (this.isStopped) { - return ; - } - var sad = new SingleAssignmentDisposable(); - this.g.add(sad); - isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); - sad.setDisposable(innerSource.subscribe(new InnerObserver(this, this.g, sad))); - }; - MergeAllObserver.prototype.onError = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.o.onError(e); - } - }; - MergeAllObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - this.isStopped = true; - this.done = true; - this.g.length === 1 && this.o.onCompleted(); - } - }; - MergeAllObserver.prototype.dispose = function() { - this.isStopped = true; - }; - MergeAllObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.o.onError(e); - return true; - } - return false; - }; - function InnerObserver(parent, g, sad) { - this.parent = parent; - this.g = g; - this.sad = sad; - this.isStopped = false; - } - InnerObserver.prototype.onNext = function(x) { - if (!this.isStopped) { - this.parent.o.onNext(x); - } - }; - InnerObserver.prototype.onError = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.parent.o.onError(e); - } - }; - InnerObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - var parent = this.parent; - this.isStopped = true; - parent.g.remove(this.sad); - parent.done && parent.g.length === 1 && parent.o.onCompleted(); - } - }; - InnerObserver.prototype.dispose = function() { - this.isStopped = true; - }; - InnerObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.parent.o.onError(e); - return true; - } - return false; - }; - return MergeAllObserver; - }()); - observableProto.mergeAll = observableProto.mergeObservable = function() { - return new MergeAllObservable(this); - }; - var CompositeError = Rx.CompositeError = function(errors) { - this.name = "NotImplementedError"; - this.innerErrors = errors; - this.message = 'This contains multiple errors. Check the innerErrors'; - Error.call(this); - }; - CompositeError.prototype = Error.prototype; - Observable.mergeDelayError = function() { - var args; - if (Array.isArray(arguments[0])) { - args = arguments[0]; - } else { - var len = arguments.length; - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - } - var source = observableOf(null, args); - return new AnonymousObservable(function(o) { - var group = new CompositeDisposable(), - m = new SingleAssignmentDisposable(), - isStopped = false, - errors = []; - function setCompletion() { - if (errors.length === 0) { - o.onCompleted(); - } else if (errors.length === 1) { - o.onError(errors[0]); - } else { - o.onError(new CompositeError(errors)); - } - } - group.add(m); - m.setDisposable(source.subscribe(function(innerSource) { - var innerSubscription = new SingleAssignmentDisposable(); - group.add(innerSubscription); - isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); - innerSubscription.setDisposable(innerSource.subscribe(function(x) { - o.onNext(x); - }, function(e) { - errors.push(e); - group.remove(innerSubscription); - isStopped && group.length === 1 && setCompletion(); - }, function() { - group.remove(innerSubscription); - isStopped && group.length === 1 && setCompletion(); - })); - }, function(e) { - errors.push(e); - isStopped = true; - group.length === 1 && setCompletion(); - }, function() { - isStopped = true; - group.length === 1 && setCompletion(); - })); - return group; - }); - }; - observableProto.onErrorResumeNext = function(second) { - if (!second) { - throw new Error('Second observable is required'); - } - return onErrorResumeNext([this, second]); - }; - var onErrorResumeNext = Observable.onErrorResumeNext = function() { - var sources = []; - if (Array.isArray(arguments[0])) { - sources = arguments[0]; - } else { - for (var i = 0, - len = arguments.length; i < len; i++) { - sources.push(arguments[i]); - } - } - return new AnonymousObservable(function(observer) { - var pos = 0, - subscription = new SerialDisposable(), - cancelable = immediateScheduler.scheduleRecursive(function(self) { - var current, - d; - if (pos < sources.length) { - current = sources[pos++]; - isPromise(current) && (current = observableFromPromise(current)); - d = new SingleAssignmentDisposable(); - subscription.setDisposable(d); - d.setDisposable(current.subscribe(observer.onNext.bind(observer), self, self)); - } else { - observer.onCompleted(); - } - }); - return new CompositeDisposable(subscription, cancelable); - }); - }; - observableProto.skipUntil = function(other) { - var source = this; - return new AnonymousObservable(function(o) { - var isOpen = false; - var disposables = new CompositeDisposable(source.subscribe(function(left) { - isOpen && o.onNext(left); - }, function(e) { - o.onError(e); - }, function() { - isOpen && o.onCompleted(); - })); - isPromise(other) && (other = observableFromPromise(other)); - var rightSubscription = new SingleAssignmentDisposable(); - disposables.add(rightSubscription); - rightSubscription.setDisposable(other.subscribe(function() { - isOpen = true; - rightSubscription.dispose(); - }, function(e) { - o.onError(e); - }, function() { - rightSubscription.dispose(); - })); - return disposables; - }, source); - }; - observableProto['switch'] = observableProto.switchLatest = function() { - var sources = this; - return new AnonymousObservable(function(observer) { - var hasLatest = false, - innerSubscription = new SerialDisposable(), - isStopped = false, - latest = 0, - subscription = sources.subscribe(function(innerSource) { - var d = new SingleAssignmentDisposable(), - id = ++latest; - hasLatest = true; - innerSubscription.setDisposable(d); - isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); - d.setDisposable(innerSource.subscribe(function(x) { - latest === id && observer.onNext(x); - }, function(e) { - latest === id && observer.onError(e); - }, function() { - if (latest === id) { - hasLatest = false; - isStopped && observer.onCompleted(); - } - })); - }, function(e) { - observer.onError(e); - }, function() { - isStopped = true; - !hasLatest && observer.onCompleted(); - }); - return new CompositeDisposable(subscription, innerSubscription); - }, sources); - }; - observableProto.takeUntil = function(other) { - var source = this; - return new AnonymousObservable(function(o) { - isPromise(other) && (other = observableFromPromise(other)); - return new CompositeDisposable(source.subscribe(o), other.subscribe(function() { - o.onCompleted(); - }, function(e) { - o.onError(e); - }, noop)); - }, source); - }; - observableProto.withLatestFrom = function() { - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - var resultSelector = args.pop(), - source = this; - if (typeof source === 'undefined') { - throw new Error('Source observable not found for withLatestFrom().'); - } - if (typeof resultSelector !== 'function') { - throw new Error('withLatestFrom() expects a resultSelector function.'); - } - if (Array.isArray(args[0])) { - args = args[0]; - } - return new AnonymousObservable(function(observer) { - var falseFactory = function() { - return false; - }, - n = args.length, - hasValue = arrayInitialize(n, falseFactory), - hasValueAll = false, - values = new Array(n); - var subscriptions = new Array(n + 1); - for (var idx = 0; idx < n; idx++) { - (function(i) { - var other = args[i], - sad = new SingleAssignmentDisposable(); - isPromise(other) && (other = observableFromPromise(other)); - sad.setDisposable(other.subscribe(function(x) { - values[i] = x; - hasValue[i] = true; - hasValueAll = hasValue.every(identity); - }, observer.onError.bind(observer), function() {})); - subscriptions[i] = sad; - }(idx)); - } - var sad = new SingleAssignmentDisposable(); - sad.setDisposable(source.subscribe(function(x) { - var res; - var allValues = [x].concat(values); - if (!hasValueAll) - return ; - try { - res = resultSelector.apply(null, allValues); - } catch (ex) { - observer.onError(ex); - return ; - } - observer.onNext(res); - }, observer.onError.bind(observer), function() { - observer.onCompleted(); - })); - subscriptions[n] = sad; - return new CompositeDisposable(subscriptions); - }, this); - }; - function zipArray(second, resultSelector) { - var first = this; - return new AnonymousObservable(function(observer) { - var index = 0, - len = second.length; - return first.subscribe(function(left) { - if (index < len) { - var right = second[index++], - result; - try { - result = resultSelector(left, right); - } catch (e) { - return observer.onError(e); - } - observer.onNext(result); - } else { - observer.onCompleted(); - } - }, function(e) { - observer.onError(e); - }, function() { - observer.onCompleted(); - }); - }, first); - } - function falseFactory() { - return false; - } - function emptyArrayFactory() { - return []; - } - observableProto.zip = function() { - if (Array.isArray(arguments[0])) { - return zipArray.apply(this, arguments); - } - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - var parent = this, - resultSelector = args.pop(); - args.unshift(parent); - return new AnonymousObservable(function(observer) { - var n = args.length, - queues = arrayInitialize(n, emptyArrayFactory), - isDone = arrayInitialize(n, falseFactory); - function next(i) { - var res, - queuedValues; - if (queues.every(function(x) { - return x.length > 0; - })) { - try { - queuedValues = queues.map(function(x) { - return x.shift(); - }); - res = resultSelector.apply(parent, queuedValues); - } catch (ex) { - observer.onError(ex); - return ; - } - observer.onNext(res); - } else if (isDone.filter(function(x, j) { - return j !== i; - }).every(identity)) { - observer.onCompleted(); - } - } - ; - function done(i) { - isDone[i] = true; - if (isDone.every(function(x) { - return x; - })) { - observer.onCompleted(); - } - } - var subscriptions = new Array(n); - for (var idx = 0; idx < n; idx++) { - (function(i) { - var source = args[i], - sad = new SingleAssignmentDisposable(); - isPromise(source) && (source = observableFromPromise(source)); - sad.setDisposable(source.subscribe(function(x) { - queues[i].push(x); - next(i); - }, function(e) { - observer.onError(e); - }, function() { - done(i); - })); - subscriptions[i] = sad; - })(idx); - } - return new CompositeDisposable(subscriptions); - }, parent); - }; - Observable.zip = function() { - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - var first = args.shift(); - return first.zip.apply(first, args); - }; - Observable.zipArray = function() { - var sources; - if (Array.isArray(arguments[0])) { - sources = arguments[0]; - } else { - var len = arguments.length; - sources = new Array(len); - for (var i = 0; i < len; i++) { - sources[i] = arguments[i]; - } - } - return new AnonymousObservable(function(observer) { - var n = sources.length, - queues = arrayInitialize(n, function() { - return []; - }), - isDone = arrayInitialize(n, function() { - return false; - }); - function next(i) { - if (queues.every(function(x) { - return x.length > 0; - })) { - var res = queues.map(function(x) { - return x.shift(); - }); - observer.onNext(res); - } else if (isDone.filter(function(x, j) { - return j !== i; - }).every(identity)) { - observer.onCompleted(); - return ; - } - } - ; - function done(i) { - isDone[i] = true; - if (isDone.every(identity)) { - observer.onCompleted(); - return ; - } - } - var subscriptions = new Array(n); - for (var idx = 0; idx < n; idx++) { - (function(i) { - subscriptions[i] = new SingleAssignmentDisposable(); - subscriptions[i].setDisposable(sources[i].subscribe(function(x) { - queues[i].push(x); - next(i); - }, function(e) { - observer.onError(e); - }, function() { - done(i); - })); - })(idx); - } - return new CompositeDisposable(subscriptions); - }); - }; - observableProto.asObservable = function() { - var source = this; - return new AnonymousObservable(function(o) { - return source.subscribe(o); - }, this); - }; - observableProto.bufferWithCount = function(count, skip) { - if (typeof skip !== 'number') { - skip = count; - } - return this.windowWithCount(count, skip).selectMany(function(x) { - return x.toArray(); - }).where(function(x) { - return x.length > 0; - }); - }; - observableProto.dematerialize = function() { - var source = this; - return new AnonymousObservable(function(o) { - return source.subscribe(function(x) { - return x.accept(o); - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, this); - }; - observableProto.distinctUntilChanged = function(keySelector, comparer) { - var source = this; - comparer || (comparer = defaultComparer); - return new AnonymousObservable(function(o) { - var hasCurrentKey = false, - currentKey; - return source.subscribe(function(value) { - var key = value; - if (keySelector) { - try { - key = keySelector(value); - } catch (e) { - o.onError(e); - return ; - } - } - if (hasCurrentKey) { - try { - var comparerEquals = comparer(currentKey, key); - } catch (e) { - o.onError(e); - return ; - } - } - if (!hasCurrentKey || !comparerEquals) { - hasCurrentKey = true; - currentKey = key; - o.onNext(value); - } - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, this); - }; - observableProto['do'] = observableProto.tap = observableProto.doAction = function(observerOrOnNext, onError, onCompleted) { - var source = this; - return new AnonymousObservable(function(observer) { - var tapObserver = !observerOrOnNext || isFunction(observerOrOnNext) ? observerCreate(observerOrOnNext || noop, onError || noop, onCompleted || noop) : observerOrOnNext; - return source.subscribe(function(x) { - try { - tapObserver.onNext(x); - } catch (e) { - observer.onError(e); - } - observer.onNext(x); - }, function(err) { - try { - tapObserver.onError(err); - } catch (e) { - observer.onError(e); - } - observer.onError(err); - }, function() { - try { - tapObserver.onCompleted(); - } catch (e) { - observer.onError(e); - } - observer.onCompleted(); - }); - }, this); - }; - observableProto.doOnNext = observableProto.tapOnNext = function(onNext, thisArg) { - return this.tap(typeof thisArg !== 'undefined' ? function(x) { - onNext.call(thisArg, x); - } : onNext); - }; - observableProto.doOnError = observableProto.tapOnError = function(onError, thisArg) { - return this.tap(noop, typeof thisArg !== 'undefined' ? function(e) { - onError.call(thisArg, e); - } : onError); - }; - observableProto.doOnCompleted = observableProto.tapOnCompleted = function(onCompleted, thisArg) { - return this.tap(noop, null, typeof thisArg !== 'undefined' ? function() { - onCompleted.call(thisArg); - } : onCompleted); - }; - observableProto['finally'] = observableProto.ensure = function(action) { - var source = this; - return new AnonymousObservable(function(observer) { - var subscription; - try { - subscription = source.subscribe(observer); - } catch (e) { - action(); - throw e; - } - return disposableCreate(function() { - try { - subscription.dispose(); - } catch (e) { - throw e; - } finally { - action(); - } - }); - }, this); - }; - observableProto.finallyAction = function(action) { - return this.ensure(action); - }; - observableProto.ignoreElements = function() { - var source = this; - return new AnonymousObservable(function(o) { - return source.subscribe(noop, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, source); - }; - observableProto.materialize = function() { - var source = this; - return new AnonymousObservable(function(observer) { - return source.subscribe(function(value) { - observer.onNext(notificationCreateOnNext(value)); - }, function(e) { - observer.onNext(notificationCreateOnError(e)); - observer.onCompleted(); - }, function() { - observer.onNext(notificationCreateOnCompleted()); - observer.onCompleted(); - }); - }, source); - }; - observableProto.repeat = function(repeatCount) { - return enumerableRepeat(this, repeatCount).concat(); - }; - observableProto.retry = function(retryCount) { - return enumerableRepeat(this, retryCount).catchError(); - }; - observableProto.retryWhen = function(notifier) { - return enumerableRepeat(this).catchErrorWhen(notifier); - }; - observableProto.scan = function() { - var hasSeed = false, - seed, - accumulator, - source = this; - if (arguments.length === 2) { - hasSeed = true; - seed = arguments[0]; - accumulator = arguments[1]; - } else { - accumulator = arguments[0]; - } - return new AnonymousObservable(function(o) { - var hasAccumulation, - accumulation, - hasValue; - return source.subscribe(function(x) { - !hasValue && (hasValue = true); - try { - if (hasAccumulation) { - accumulation = accumulator(accumulation, x); - } else { - accumulation = hasSeed ? accumulator(seed, x) : x; - hasAccumulation = true; - } - } catch (e) { - o.onError(e); - return ; - } - o.onNext(accumulation); - }, function(e) { - o.onError(e); - }, function() { - !hasValue && hasSeed && o.onNext(seed); - o.onCompleted(); - }); - }, source); - }; - observableProto.skipLast = function(count) { - if (count < 0) { - throw new ArgumentOutOfRangeError(); - } - var source = this; - return new AnonymousObservable(function(o) { - var q = []; - return source.subscribe(function(x) { - q.push(x); - q.length > count && o.onNext(q.shift()); - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, source); - }; - observableProto.startWith = function() { - var values, - scheduler, - start = 0; - if (!!arguments.length && isScheduler(arguments[0])) { - scheduler = arguments[0]; - start = 1; - } else { - scheduler = immediateScheduler; - } - for (var args = [], - i = start, - len = arguments.length; i < len; i++) { - args.push(arguments[i]); - } - return enumerableOf([observableFromArray(args, scheduler), this]).concat(); - }; - observableProto.takeLast = function(count) { - if (count < 0) { - throw new ArgumentOutOfRangeError(); - } - var source = this; - return new AnonymousObservable(function(o) { - var q = []; - return source.subscribe(function(x) { - q.push(x); - q.length > count && q.shift(); - }, function(e) { - o.onError(e); - }, function() { - while (q.length > 0) { - o.onNext(q.shift()); - } - o.onCompleted(); - }); - }, source); - }; - observableProto.takeLastBuffer = function(count) { - var source = this; - return new AnonymousObservable(function(o) { - var q = []; - return source.subscribe(function(x) { - q.push(x); - q.length > count && q.shift(); - }, function(e) { - o.onError(e); - }, function() { - o.onNext(q); - o.onCompleted(); - }); - }, source); - }; - observableProto.windowWithCount = function(count, skip) { - var source = this; - +count || (count = 0); - Math.abs(count) === Infinity && (count = 0); - if (count <= 0) { - throw new ArgumentOutOfRangeError(); - } - skip == null && (skip = count); - +skip || (skip = 0); - Math.abs(skip) === Infinity && (skip = 0); - if (skip <= 0) { - throw new ArgumentOutOfRangeError(); - } - return new AnonymousObservable(function(observer) { - var m = new SingleAssignmentDisposable(), - refCountDisposable = new RefCountDisposable(m), - n = 0, - q = []; - function createWindow() { - var s = new Subject(); - q.push(s); - observer.onNext(addRef(s, refCountDisposable)); - } - createWindow(); - m.setDisposable(source.subscribe(function(x) { - for (var i = 0, - len = q.length; i < len; i++) { - q[i].onNext(x); - } - var c = n - count + 1; - c >= 0 && c % skip === 0 && q.shift().onCompleted(); - ++n % skip === 0 && createWindow(); - }, function(e) { - while (q.length > 0) { - q.shift().onError(e); - } - observer.onError(e); - }, function() { - while (q.length > 0) { - q.shift().onCompleted(); - } - observer.onCompleted(); - })); - return refCountDisposable; - }, source); - }; - function concatMap(source, selector, thisArg) { - var selectorFunc = bindCallback(selector, thisArg, 3); - return source.map(function(x, i) { - var result = selectorFunc(x, i, source); - isPromise(result) && (result = observableFromPromise(result)); - (isArrayLike(result) || isIterable(result)) && (result = observableFrom(result)); - return result; - }).concatAll(); - } - observableProto.selectConcat = observableProto.concatMap = function(selector, resultSelector, thisArg) { - if (isFunction(selector) && isFunction(resultSelector)) { - return this.concatMap(function(x, i) { - var selectorResult = selector(x, i); - isPromise(selectorResult) && (selectorResult = observableFromPromise(selectorResult)); - (isArrayLike(selectorResult) || isIterable(selectorResult)) && (selectorResult = observableFrom(selectorResult)); - return selectorResult.map(function(y, i2) { - return resultSelector(x, y, i, i2); - }); - }); - } - return isFunction(selector) ? concatMap(this, selector, thisArg) : concatMap(this, function() { - return selector; - }); - }; - observableProto.concatMapObserver = observableProto.selectConcatObserver = function(onNext, onError, onCompleted, thisArg) { - var source = this, - onNextFunc = bindCallback(onNext, thisArg, 2), - onErrorFunc = bindCallback(onError, thisArg, 1), - onCompletedFunc = bindCallback(onCompleted, thisArg, 0); - return new AnonymousObservable(function(observer) { - var index = 0; - return source.subscribe(function(x) { - var result; - try { - result = onNextFunc(x, index++); - } catch (e) { - observer.onError(e); - return ; - } - isPromise(result) && (result = observableFromPromise(result)); - observer.onNext(result); - }, function(err) { - var result; - try { - result = onErrorFunc(err); - } catch (e) { - observer.onError(e); - return ; - } - isPromise(result) && (result = observableFromPromise(result)); - observer.onNext(result); - observer.onCompleted(); - }, function() { - var result; - try { - result = onCompletedFunc(); - } catch (e) { - observer.onError(e); - return ; - } - isPromise(result) && (result = observableFromPromise(result)); - observer.onNext(result); - observer.onCompleted(); - }); - }, this).concatAll(); - }; - observableProto.defaultIfEmpty = function(defaultValue) { - var source = this; - defaultValue === undefined && (defaultValue = null); - return new AnonymousObservable(function(observer) { - var found = false; - return source.subscribe(function(x) { - found = true; - observer.onNext(x); - }, function(e) { - observer.onError(e); - }, function() { - !found && observer.onNext(defaultValue); - observer.onCompleted(); - }); - }, source); - }; - function arrayIndexOfComparer(array, item, comparer) { - for (var i = 0, - len = array.length; i < len; i++) { - if (comparer(array[i], item)) { - return i; - } - } - return -1; - } - function HashSet(comparer) { - this.comparer = comparer; - this.set = []; - } - HashSet.prototype.push = function(value) { - var retValue = arrayIndexOfComparer(this.set, value, this.comparer) === -1; - retValue && this.set.push(value); - return retValue; - }; - observableProto.distinct = function(keySelector, comparer) { - var source = this; - comparer || (comparer = defaultComparer); - return new AnonymousObservable(function(o) { - var hashSet = new HashSet(comparer); - return source.subscribe(function(x) { - var key = x; - if (keySelector) { - try { - key = keySelector(x); - } catch (e) { - o.onError(e); - return ; - } - } - hashSet.push(key) && o.onNext(x); - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, this); - }; - observableProto.groupBy = function(keySelector, elementSelector, comparer) { - return this.groupByUntil(keySelector, elementSelector, observableNever, comparer); - }; - observableProto.groupByUntil = function(keySelector, elementSelector, durationSelector, comparer) { - var source = this; - elementSelector || (elementSelector = identity); - comparer || (comparer = defaultComparer); - return new AnonymousObservable(function(observer) { - function handleError(e) { - return function(item) { - item.onError(e); - }; - } - var map = new Dictionary(0, comparer), - groupDisposable = new CompositeDisposable(), - refCountDisposable = new RefCountDisposable(groupDisposable); - groupDisposable.add(source.subscribe(function(x) { - var key; - try { - key = keySelector(x); - } catch (e) { - map.getValues().forEach(handleError(e)); - observer.onError(e); - return ; - } - var fireNewMapEntry = false, - writer = map.tryGetValue(key); - if (!writer) { - writer = new Subject(); - map.set(key, writer); - fireNewMapEntry = true; - } - if (fireNewMapEntry) { - var group = new GroupedObservable(key, writer, refCountDisposable), - durationGroup = new GroupedObservable(key, writer); - try { - duration = durationSelector(durationGroup); - } catch (e) { - map.getValues().forEach(handleError(e)); - observer.onError(e); - return ; - } - observer.onNext(group); - var md = new SingleAssignmentDisposable(); - groupDisposable.add(md); - var expire = function() { - map.remove(key) && writer.onCompleted(); - groupDisposable.remove(md); - }; - md.setDisposable(duration.take(1).subscribe(noop, function(exn) { - map.getValues().forEach(handleError(exn)); - observer.onError(exn); - }, expire)); - } - var element; - try { - element = elementSelector(x); - } catch (e) { - map.getValues().forEach(handleError(e)); - observer.onError(e); - return ; - } - writer.onNext(element); - }, function(ex) { - map.getValues().forEach(handleError(ex)); - observer.onError(ex); - }, function() { - map.getValues().forEach(function(item) { - item.onCompleted(); - }); - observer.onCompleted(); - })); - return refCountDisposable; - }, source); - }; - var MapObservable = (function(__super__) { - inherits(MapObservable, __super__); - function MapObservable(source, selector, thisArg) { - this.source = source; - this.selector = bindCallback(selector, thisArg, 3); - __super__.call(this); - } - MapObservable.prototype.internalMap = function(selector, thisArg) { - var self = this; - return new MapObservable(this.source, function(x, i, o) { - return selector.call(this, self.selector(x, i, o), i, o); - }, thisArg); - }; - MapObservable.prototype.subscribeCore = function(observer) { - return this.source.subscribe(new MapObserver(observer, this.selector, this)); - }; - return MapObservable; - }(ObservableBase)); - function MapObserver(observer, selector, source) { - this.observer = observer; - this.selector = selector; - this.source = source; - this.i = 0; - this.isStopped = false; - } - MapObserver.prototype.onNext = function(x) { - if (this.isStopped) { - return ; - } - var result = tryCatch(this.selector).call(this, x, this.i++, this.source); - if (result === errorObj) { - return this.observer.onError(result.e); - } - this.observer.onNext(result); - }; - MapObserver.prototype.onError = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onError(e); - } - }; - MapObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onCompleted(); - } - }; - MapObserver.prototype.dispose = function() { - this.isStopped = true; - }; - MapObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onError(e); - return true; - } - return false; - }; - observableProto.map = observableProto.select = function(selector, thisArg) { - var selectorFn = typeof selector === 'function' ? selector : function() { - return selector; - }; - return this instanceof MapObservable ? this.internalMap(selectorFn, thisArg) : new MapObservable(this, selectorFn, thisArg); - }; - observableProto.pluck = function() { - var args = arguments, - len = arguments.length; - if (len === 0) { - throw new Error('List of properties cannot be empty.'); - } - return this.map(function(x) { - var currentProp = x; - for (var i = 0; i < len; i++) { - var p = currentProp[args[i]]; - if (typeof p !== 'undefined') { - currentProp = p; - } else { - return undefined; - } - } - return currentProp; - }); - }; - function flatMap(source, selector, thisArg) { - var selectorFunc = bindCallback(selector, thisArg, 3); - return source.map(function(x, i) { - var result = selectorFunc(x, i, source); - isPromise(result) && (result = observableFromPromise(result)); - (isArrayLike(result) || isIterable(result)) && (result = observableFrom(result)); - return result; - }).mergeAll(); - } - observableProto.selectMany = observableProto.flatMap = function(selector, resultSelector, thisArg) { - if (isFunction(selector) && isFunction(resultSelector)) { - return this.flatMap(function(x, i) { - var selectorResult = selector(x, i); - isPromise(selectorResult) && (selectorResult = observableFromPromise(selectorResult)); - (isArrayLike(selectorResult) || isIterable(selectorResult)) && (selectorResult = observableFrom(selectorResult)); - return selectorResult.map(function(y, i2) { - return resultSelector(x, y, i, i2); - }); - }, thisArg); - } - return isFunction(selector) ? flatMap(this, selector, thisArg) : flatMap(this, function() { - return selector; - }); - }; - observableProto.flatMapObserver = observableProto.selectManyObserver = function(onNext, onError, onCompleted, thisArg) { - var source = this; - return new AnonymousObservable(function(observer) { - var index = 0; - return source.subscribe(function(x) { - var result; - try { - result = onNext.call(thisArg, x, index++); - } catch (e) { - observer.onError(e); - return ; - } - isPromise(result) && (result = observableFromPromise(result)); - observer.onNext(result); - }, function(err) { - var result; - try { - result = onError.call(thisArg, err); - } catch (e) { - observer.onError(e); - return ; - } - isPromise(result) && (result = observableFromPromise(result)); - observer.onNext(result); - observer.onCompleted(); - }, function() { - var result; - try { - result = onCompleted.call(thisArg); - } catch (e) { - observer.onError(e); - return ; - } - isPromise(result) && (result = observableFromPromise(result)); - observer.onNext(result); - observer.onCompleted(); - }); - }, source).mergeAll(); - }; - observableProto.selectSwitch = observableProto.flatMapLatest = observableProto.switchMap = function(selector, thisArg) { - return this.select(selector, thisArg).switchLatest(); - }; - observableProto.skip = function(count) { - if (count < 0) { - throw new ArgumentOutOfRangeError(); - } - var source = this; - return new AnonymousObservable(function(o) { - var remaining = count; - return source.subscribe(function(x) { - if (remaining <= 0) { - o.onNext(x); - } else { - remaining--; - } - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, source); - }; - observableProto.skipWhile = function(predicate, thisArg) { - var source = this, - callback = bindCallback(predicate, thisArg, 3); - return new AnonymousObservable(function(o) { - var i = 0, - running = false; - return source.subscribe(function(x) { - if (!running) { - try { - running = !callback(x, i++, source); - } catch (e) { - o.onError(e); - return ; - } - } - running && o.onNext(x); - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, source); - }; - observableProto.take = function(count, scheduler) { - if (count < 0) { - throw new ArgumentOutOfRangeError(); - } - if (count === 0) { - return observableEmpty(scheduler); - } - var source = this; - return new AnonymousObservable(function(o) { - var remaining = count; - return source.subscribe(function(x) { - if (remaining-- > 0) { - o.onNext(x); - remaining === 0 && o.onCompleted(); - } - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, source); - }; - observableProto.takeWhile = function(predicate, thisArg) { - var source = this, - callback = bindCallback(predicate, thisArg, 3); - return new AnonymousObservable(function(o) { - var i = 0, - running = true; - return source.subscribe(function(x) { - if (running) { - try { - running = callback(x, i++, source); - } catch (e) { - o.onError(e); - return ; - } - if (running) { - o.onNext(x); - } else { - o.onCompleted(); - } - } - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, source); - }; - var FilterObservable = (function(__super__) { - inherits(FilterObservable, __super__); - function FilterObservable(source, predicate, thisArg) { - this.source = source; - this.predicate = bindCallback(predicate, thisArg, 3); - __super__.call(this); - } - FilterObservable.prototype.subscribeCore = function(observer) { - return this.source.subscribe(new FilterObserver(observer, this.predicate, this)); - }; - FilterObservable.prototype.internalFilter = function(predicate, thisArg) { - var self = this; - return new FilterObservable(this.source, function(x, i, o) { - return self.predicate(x, i, o) && predicate.call(this, x, i, o); - }, thisArg); - }; - return FilterObservable; - }(ObservableBase)); - function FilterObserver(observer, predicate, source) { - this.observer = observer; - this.predicate = predicate; - this.source = source; - this.i = 0; - this.isStopped = false; - } - FilterObserver.prototype.onNext = function(x) { - if (this.isStopped) { - return ; - } - var shouldYield = tryCatch(this.predicate).call(this, x, this.i++, this.source); - if (shouldYield === errorObj) { - return this.observer.onError(shouldYield.e); - } - shouldYield && this.observer.onNext(x); - }; - FilterObserver.prototype.onError = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onError(e); - } - }; - FilterObserver.prototype.onCompleted = function() { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onCompleted(); - } - }; - FilterObserver.prototype.dispose = function() { - this.isStopped = true; - }; - FilterObserver.prototype.fail = function(e) { - if (!this.isStopped) { - this.isStopped = true; - this.observer.onError(e); - return true; - } - return false; - }; - observableProto.filter = observableProto.where = function(predicate, thisArg) { - return this instanceof FilterObservable ? this.internalFilter(predicate, thisArg) : new FilterObservable(this, predicate, thisArg); - }; - function extremaBy(source, keySelector, comparer) { - return new AnonymousObservable(function(o) { - var hasValue = false, - lastKey = null, - list = []; - return source.subscribe(function(x) { - var comparison, - key; - try { - key = keySelector(x); - } catch (ex) { - o.onError(ex); - return ; - } - comparison = 0; - if (!hasValue) { - hasValue = true; - lastKey = key; - } else { - try { - comparison = comparer(key, lastKey); - } catch (ex1) { - o.onError(ex1); - return ; - } - } - if (comparison > 0) { - lastKey = key; - list = []; - } - if (comparison >= 0) { - list.push(x); - } - }, function(e) { - o.onError(e); - }, function() { - o.onNext(list); - o.onCompleted(); - }); - }, source); - } - function firstOnly(x) { - if (x.length === 0) { - throw new EmptyError(); - } - return x[0]; - } - observableProto.aggregate = function() { - var hasSeed = false, - accumulator, - seed, - source = this; - if (arguments.length === 2) { - hasSeed = true; - seed = arguments[0]; - accumulator = arguments[1]; - } else { - accumulator = arguments[0]; - } - return new AnonymousObservable(function(o) { - var hasAccumulation, - accumulation, - hasValue; - return source.subscribe(function(x) { - !hasValue && (hasValue = true); - try { - if (hasAccumulation) { - accumulation = accumulator(accumulation, x); - } else { - accumulation = hasSeed ? accumulator(seed, x) : x; - hasAccumulation = true; - } - } catch (e) { - return o.onError(e); - } - }, function(e) { - o.onError(e); - }, function() { - hasValue && o.onNext(accumulation); - !hasValue && hasSeed && o.onNext(seed); - !hasValue && !hasSeed && o.onError(new EmptyError()); - o.onCompleted(); - }); - }, source); - }; - observableProto.reduce = function(accumulator) { - var hasSeed = false, - seed, - source = this; - if (arguments.length === 2) { - hasSeed = true; - seed = arguments[1]; - } - return new AnonymousObservable(function(o) { - var hasAccumulation, - accumulation, - hasValue; - return source.subscribe(function(x) { - !hasValue && (hasValue = true); - try { - if (hasAccumulation) { - accumulation = accumulator(accumulation, x); - } else { - accumulation = hasSeed ? accumulator(seed, x) : x; - hasAccumulation = true; - } - } catch (e) { - return o.onError(e); - } - }, function(e) { - o.onError(e); - }, function() { - hasValue && o.onNext(accumulation); - !hasValue && hasSeed && o.onNext(seed); - !hasValue && !hasSeed && o.onError(new EmptyError()); - o.onCompleted(); - }); - }, source); - }; - observableProto.some = function(predicate, thisArg) { - var source = this; - return predicate ? source.filter(predicate, thisArg).some() : new AnonymousObservable(function(observer) { - return source.subscribe(function() { - observer.onNext(true); - observer.onCompleted(); - }, function(e) { - observer.onError(e); - }, function() { - observer.onNext(false); - observer.onCompleted(); - }); - }, source); - }; - observableProto.any = function() { - return this.some.apply(this, arguments); - }; - observableProto.isEmpty = function() { - return this.any().map(not); - }; - observableProto.every = function(predicate, thisArg) { - return this.filter(function(v) { - return !predicate(v); - }, thisArg).some().map(not); - }; - observableProto.all = function() { - return this.every.apply(this, arguments); - }; - observableProto.includes = function(searchElement, fromIndex) { - var source = this; - function comparer(a, b) { - return (a === 0 && b === 0) || (a === b || (isNaN(a) && isNaN(b))); - } - return new AnonymousObservable(function(o) { - var i = 0, - n = +fromIndex || 0; - Math.abs(n) === Infinity && (n = 0); - if (n < 0) { - o.onNext(false); - o.onCompleted(); - return disposableEmpty; - } - return source.subscribe(function(x) { - if (i++ >= n && comparer(x, searchElement)) { - o.onNext(true); - o.onCompleted(); - } - }, function(e) { - o.onError(e); - }, function() { - o.onNext(false); - o.onCompleted(); - }); - }, this); - }; - observableProto.contains = function(searchElement, fromIndex) { - observableProto.includes(searchElement, fromIndex); - }; - observableProto.count = function(predicate, thisArg) { - return predicate ? this.filter(predicate, thisArg).count() : this.reduce(function(count) { - return count + 1; - }, 0); - }; - observableProto.indexOf = function(searchElement, fromIndex) { - var source = this; - return new AnonymousObservable(function(o) { - var i = 0, - n = +fromIndex || 0; - Math.abs(n) === Infinity && (n = 0); - if (n < 0) { - o.onNext(-1); - o.onCompleted(); - return disposableEmpty; - } - return source.subscribe(function(x) { - if (i >= n && x === searchElement) { - o.onNext(i); - o.onCompleted(); - } - i++; - }, function(e) { - o.onError(e); - }, function() { - o.onNext(-1); - o.onCompleted(); - }); - }, source); - }; - observableProto.sum = function(keySelector, thisArg) { - return keySelector && isFunction(keySelector) ? this.map(keySelector, thisArg).sum() : this.reduce(function(prev, curr) { - return prev + curr; - }, 0); - }; - observableProto.minBy = function(keySelector, comparer) { - comparer || (comparer = defaultSubComparer); - return extremaBy(this, keySelector, function(x, y) { - return comparer(x, y) * -1; - }); - }; - observableProto.min = function(comparer) { - return this.minBy(identity, comparer).map(function(x) { - return firstOnly(x); - }); - }; - observableProto.maxBy = function(keySelector, comparer) { - comparer || (comparer = defaultSubComparer); - return extremaBy(this, keySelector, comparer); - }; - observableProto.max = function(comparer) { - return this.maxBy(identity, comparer).map(function(x) { - return firstOnly(x); - }); - }; - observableProto.average = function(keySelector, thisArg) { - return keySelector && isFunction(keySelector) ? this.map(keySelector, thisArg).average() : this.reduce(function(prev, cur) { - return { - sum: prev.sum + cur, - count: prev.count + 1 - }; - }, { - sum: 0, - count: 0 - }).map(function(s) { - if (s.count === 0) { - throw new EmptyError(); - } - return s.sum / s.count; - }); - }; - observableProto.sequenceEqual = function(second, comparer) { - var first = this; - comparer || (comparer = defaultComparer); - return new AnonymousObservable(function(o) { - var donel = false, - doner = false, - ql = [], - qr = []; - var subscription1 = first.subscribe(function(x) { - var equal, - v; - if (qr.length > 0) { - v = qr.shift(); - try { - equal = comparer(v, x); - } catch (e) { - o.onError(e); - return ; - } - if (!equal) { - o.onNext(false); - o.onCompleted(); - } - } else if (doner) { - o.onNext(false); - o.onCompleted(); - } else { - ql.push(x); - } - }, function(e) { - o.onError(e); - }, function() { - donel = true; - if (ql.length === 0) { - if (qr.length > 0) { - o.onNext(false); - o.onCompleted(); - } else if (doner) { - o.onNext(true); - o.onCompleted(); - } - } - }); - (isArrayLike(second) || isIterable(second)) && (second = observableFrom(second)); - isPromise(second) && (second = observableFromPromise(second)); - var subscription2 = second.subscribe(function(x) { - var equal; - if (ql.length > 0) { - var v = ql.shift(); - try { - equal = comparer(v, x); - } catch (exception) { - o.onError(exception); - return ; - } - if (!equal) { - o.onNext(false); - o.onCompleted(); - } - } else if (donel) { - o.onNext(false); - o.onCompleted(); - } else { - qr.push(x); - } - }, function(e) { - o.onError(e); - }, function() { - doner = true; - if (qr.length === 0) { - if (ql.length > 0) { - o.onNext(false); - o.onCompleted(); - } else if (donel) { - o.onNext(true); - o.onCompleted(); - } - } - }); - return new CompositeDisposable(subscription1, subscription2); - }, first); - }; - function elementAtOrDefault(source, index, hasDefault, defaultValue) { - if (index < 0) { - throw new ArgumentOutOfRangeError(); - } - return new AnonymousObservable(function(o) { - var i = index; - return source.subscribe(function(x) { - if (i-- === 0) { - o.onNext(x); - o.onCompleted(); - } - }, function(e) { - o.onError(e); - }, function() { - if (!hasDefault) { - o.onError(new ArgumentOutOfRangeError()); - } else { - o.onNext(defaultValue); - o.onCompleted(); - } - }); - }, source); - } - observableProto.elementAt = function(index) { - return elementAtOrDefault(this, index, false); - }; - observableProto.elementAtOrDefault = function(index, defaultValue) { - return elementAtOrDefault(this, index, true, defaultValue); - }; - function singleOrDefaultAsync(source, hasDefault, defaultValue) { - return new AnonymousObservable(function(o) { - var value = defaultValue, - seenValue = false; - return source.subscribe(function(x) { - if (seenValue) { - o.onError(new Error('Sequence contains more than one element')); - } else { - value = x; - seenValue = true; - } - }, function(e) { - o.onError(e); - }, function() { - if (!seenValue && !hasDefault) { - o.onError(new EmptyError()); - } else { - o.onNext(value); - o.onCompleted(); - } - }); - }, source); - } - observableProto.single = function(predicate, thisArg) { - return predicate && isFunction(predicate) ? this.where(predicate, thisArg).single() : singleOrDefaultAsync(this, false); - }; - observableProto.singleOrDefault = function(predicate, defaultValue, thisArg) { - return predicate && isFunction(predicate) ? this.filter(predicate, thisArg).singleOrDefault(null, defaultValue) : singleOrDefaultAsync(this, true, defaultValue); - }; - function firstOrDefaultAsync(source, hasDefault, defaultValue) { - return new AnonymousObservable(function(o) { - return source.subscribe(function(x) { - o.onNext(x); - o.onCompleted(); - }, function(e) { - o.onError(e); - }, function() { - if (!hasDefault) { - o.onError(new EmptyError()); - } else { - o.onNext(defaultValue); - o.onCompleted(); - } - }); - }, source); - } - observableProto.first = function(predicate, thisArg) { - return predicate ? this.where(predicate, thisArg).first() : firstOrDefaultAsync(this, false); - }; - observableProto.firstOrDefault = function(predicate, defaultValue, thisArg) { - return predicate ? this.where(predicate).firstOrDefault(null, defaultValue) : firstOrDefaultAsync(this, true, defaultValue); - }; - function lastOrDefaultAsync(source, hasDefault, defaultValue) { - return new AnonymousObservable(function(o) { - var value = defaultValue, - seenValue = false; - return source.subscribe(function(x) { - value = x; - seenValue = true; - }, function(e) { - o.onError(e); - }, function() { - if (!seenValue && !hasDefault) { - o.onError(new EmptyError()); - } else { - o.onNext(value); - o.onCompleted(); - } - }); - }, source); - } - observableProto.last = function(predicate, thisArg) { - return predicate ? this.where(predicate, thisArg).last() : lastOrDefaultAsync(this, false); - }; - observableProto.lastOrDefault = function(predicate, defaultValue, thisArg) { - return predicate ? this.where(predicate, thisArg).lastOrDefault(null, defaultValue) : lastOrDefaultAsync(this, true, defaultValue); - }; - function findValue(source, predicate, thisArg, yieldIndex) { - var callback = bindCallback(predicate, thisArg, 3); - return new AnonymousObservable(function(o) { - var i = 0; - return source.subscribe(function(x) { - var shouldRun; - try { - shouldRun = callback(x, i, source); - } catch (e) { - o.onError(e); - return ; - } - if (shouldRun) { - o.onNext(yieldIndex ? i : x); - o.onCompleted(); - } else { - i++; - } - }, function(e) { - o.onError(e); - }, function() { - o.onNext(yieldIndex ? -1 : undefined); - o.onCompleted(); - }); - }, source); - } - observableProto.find = function(predicate, thisArg) { - return findValue(this, predicate, thisArg, false); - }; - observableProto.findIndex = function(predicate, thisArg) { - return findValue(this, predicate, thisArg, true); - }; - observableProto.toSet = function() { - if (typeof root.Set === 'undefined') { - throw new TypeError(); - } - var source = this; - return new AnonymousObservable(function(o) { - var s = new root.Set(); - return source.subscribe(function(x) { - s.add(x); - }, function(e) { - o.onError(e); - }, function() { - o.onNext(s); - o.onCompleted(); - }); - }, source); - }; - observableProto.toMap = function(keySelector, elementSelector) { - if (typeof root.Map === 'undefined') { - throw new TypeError(); - } - var source = this; - return new AnonymousObservable(function(o) { - var m = new root.Map(); - return source.subscribe(function(x) { - var key; - try { - key = keySelector(x); - } catch (e) { - o.onError(e); - return ; - } - var element = x; - if (elementSelector) { - try { - element = elementSelector(x); - } catch (e) { - o.onError(e); - return ; - } - } - m.set(key, element); - }, function(e) { - o.onError(e); - }, function() { - o.onNext(m); - o.onCompleted(); - }); - }, source); - }; - var fnString = 'function', - throwString = 'throw', - isObject = Rx.internals.isObject; - function toThunk(obj, ctx) { - if (Array.isArray(obj)) { - return objectToThunk.call(ctx, obj); - } - if (isGeneratorFunction(obj)) { - return observableSpawn(obj.call(ctx)); - } - if (isGenerator(obj)) { - return observableSpawn(obj); - } - if (isObservable(obj)) { - return observableToThunk(obj); - } - if (isPromise(obj)) { - return promiseToThunk(obj); - } - if (typeof obj === fnString) { - return obj; - } - if (isObject(obj) || Array.isArray(obj)) { - return objectToThunk.call(ctx, obj); - } - return obj; - } - function objectToThunk(obj) { - var ctx = this; - return function(done) { - var keys = Object.keys(obj), - pending = keys.length, - results = new obj.constructor(), - finished; - if (!pending) { - timeoutScheduler.schedule(function() { - done(null, results); - }); - return ; - } - for (var i = 0, - len = keys.length; i < len; i++) { - run(obj[keys[i]], keys[i]); - } - function run(fn, key) { - if (finished) { - return ; - } - try { - fn = toThunk(fn, ctx); - if (typeof fn !== fnString) { - results[key] = fn; - return --pending || done(null, results); - } - fn.call(ctx, function(err, res) { - if (finished) { - return ; - } - if (err) { - finished = true; - return done(err); - } - results[key] = res; - --pending || done(null, results); - }); - } catch (e) { - finished = true; - done(e); - } - } - }; - } - function observableToThunk(observable) { - return function(fn) { - var value, - hasValue = false; - observable.subscribe(function(v) { - value = v; - hasValue = true; - }, fn, function() { - hasValue && fn(null, value); - }); - }; +// TODO(vicb): Create a benchmark for the different methods & the usage of the queue +// see https://github.com/angular/zone.js/issues/97 + +var len = 0; + +var hasNativePromise = typeof Promise ==! "undefined" && + Promise.toString().indexOf("[native code]") !== -1; + +var isFirefox = global.navigator && + global.navigator.userAgent.toLowerCase().indexOf('firefox') > -1; + +function asap(callback) { + queue[len] = callback; + len += 1; + if (len === 1) { + scheduleFlush(); + } +} + +var browserWindow = (typeof global.window !== 'undefined') ? global.window : undefined; +var browserGlobal = browserWindow || {}; +var BrowserMutationObserver = browserGlobal.MutationObserver || browserGlobal.WebKitMutationObserver; + +// test for web worker but not in IE10 +var isWorker = typeof Uint8ClampedArray !== 'undefined' && + typeof importScripts !== 'undefined' && + typeof MessageChannel !== 'undefined'; + +function useMutationObserver() { + var iterations = 0; + var observer = new BrowserMutationObserver(flush); + var node = document.createTextNode(''); + observer.observe(node, { characterData: true }); + + return function() { + node.data = (iterations = ++iterations % 2); + }; +} + +// web worker +function useMessageChannel() { + var channel = new MessageChannel(); + channel.port1.onmessage = flush; + return function () { + channel.port2.postMessage(0); + }; +} + +function useSetTimeout() { + return function() { + setTimeout(flush, 1); + }; +} + +function usePromise() { + var resolvedPromise = Promise.resolve(void 0); + return function() { + resolvedPromise.then(flush); + } +} + +var queue = new Array(1000); + +function flush() { + for (var i = 0; i < len; i++) { + var callback = queue[i]; + callback(); + queue[i] = undefined; + } + + len = 0; +} + +var scheduleFlush; +// Decide what async method to use to triggering processing of queued callbacks: +if (hasNativePromise && !isFirefox) { + // TODO(vicb): remove '!isFirefox' when the bug is fixed: + // https://bugzilla.mozilla.org/show_bug.cgi?id=1162013 + scheduleFlush = usePromise(); +} else if (BrowserMutationObserver) { + scheduleFlush = useMutationObserver(); +} else if (isWorker) { + scheduleFlush = useMessageChannel(); +} else { + scheduleFlush = useSetTimeout(); +} + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],5:[function(require,module,exports){ +(function (global){ +'use strict'; + +var fnPatch = require('./functions'); +var promisePatch = require('./promise'); +var mutationObserverPatch = require('./mutation-observer'); +var definePropertyPatch = require('./define-property'); +var registerElementPatch = require('./register-element'); +var webSocketPatch = require('./websocket'); +var eventTargetPatch = require('./event-target'); +var propertyDescriptorPatch = require('./property-descriptor'); + +function apply() { + fnPatch.patchSetClearFunction(global, [ + 'timeout', + 'interval', + 'immediate' + ]); + + fnPatch.patchSetFunction(global, [ + 'requestAnimationFrame', + 'mozRequestAnimationFrame', + 'webkitRequestAnimationFrame' + ]); + + fnPatch.patchFunction(global, [ + 'alert', + 'prompt' + ]); + + eventTargetPatch.apply(); + + propertyDescriptorPatch.apply(); + + promisePatch.apply(); + + mutationObserverPatch.patchClass('MutationObserver'); + mutationObserverPatch.patchClass('WebKitMutationObserver'); + + definePropertyPatch.apply(); + + registerElementPatch.apply(); +} + +module.exports = { + apply: apply +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"./define-property":6,"./event-target":7,"./functions":8,"./mutation-observer":9,"./promise":10,"./property-descriptor":11,"./register-element":12,"./websocket":13}],6:[function(require,module,exports){ +'use strict'; + +// might need similar for object.freeze +// i regret nothing + +var _defineProperty = Object.defineProperty; +var _getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor; +var _create = Object.create; + +function apply() { + Object.defineProperty = function (obj, prop, desc) { + if (isUnconfigurable(obj, prop)) { + throw new TypeError('Cannot assign to read only property \'' + prop + '\' of ' + obj); } - function promiseToThunk(promise) { - return function(fn) { - promise.then(function(res) { - fn(null, res); - }, fn); - }; + if (prop !== 'prototype') { + desc = rewriteDescriptor(obj, prop, desc); } - function isObservable(obj) { - return obj && typeof obj.subscribe === fnString; - } - function isGeneratorFunction(obj) { - return obj && obj.constructor && obj.constructor.name === 'GeneratorFunction'; - } - function isGenerator(obj) { - return obj && typeof obj.next === fnString && typeof obj[throwString] === fnString; - } - var observableSpawn = Rx.spawn = function(fn) { - var isGenFun = isGeneratorFunction(fn); - return function(done) { - var ctx = this, - gen = fn; - if (isGenFun) { - for (var args = [], - i = 0, - len = arguments.length; i < len; i++) { - args.push(arguments[i]); - } - var len = args.length, - hasCallback = len && typeof args[len - 1] === fnString; - done = hasCallback ? args.pop() : handleError; - gen = fn.apply(this, args); - } else { - done = done || handleError; - } - next(); - function exit(err, res) { - timeoutScheduler.schedule(done.bind(ctx, err, res)); - } - function next(err, res) { - var ret; - if (arguments.length > 2) { - for (var res = [], - i = 1, - len = arguments.length; i < len; i++) { - res.push(arguments[i]); - } - } - if (err) { - try { - ret = gen[throwString](err); - } catch (e) { - return exit(e); - } - } - if (!err) { - try { - ret = gen.next(res); - } catch (e) { - return exit(e); - } - } - if (ret.done) { - return exit(null, ret.value); - } - ret.value = toThunk(ret.value, ctx); - if (typeof ret.value === fnString) { - var called = false; - try { - ret.value.call(ctx, function() { - if (called) { - return ; - } - called = true; - next.apply(ctx, arguments); - }); - } catch (e) { - timeoutScheduler.schedule(function() { - if (called) { - return ; - } - called = true; - next.call(ctx, e); - }); - } - return ; - } - next(new TypeError('Rx.spawn only supports a function, Promise, Observable, Object or Array.')); - } - }; - }; - function handleError(err) { - if (!err) { - return ; - } - timeoutScheduler.schedule(function() { - throw err; + return _defineProperty(obj, prop, desc); + }; + + Object.defineProperties = function (obj, props) { + Object.keys(props).forEach(function (prop) { + Object.defineProperty(obj, prop, props[prop]); + }); + return obj; + }; + + Object.create = function (obj, proto) { + if (typeof proto === 'object') { + Object.keys(proto).forEach(function (prop) { + proto[prop] = rewriteDescriptor(obj, prop, proto[prop]); }); } - Observable.start = function(func, context, scheduler) { - return observableToAsync(func, context, scheduler)(); - }; - var observableToAsync = Observable.toAsync = function(func, context, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return function() { - var args = arguments, - subject = new AsyncSubject(); - scheduler.schedule(function() { - var result; - try { - result = func.apply(context, args); - } catch (e) { - subject.onError(e); - return ; - } - subject.onNext(result); - subject.onCompleted(); - }); - return subject.asObservable(); - }; - }; - Observable.fromCallback = function(func, context, selector) { - return function() { - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - return new AnonymousObservable(function(observer) { - function handler() { - var len = arguments.length, - results = new Array(len); - for (var i = 0; i < len; i++) { - results[i] = arguments[i]; - } - if (selector) { - try { - results = selector.apply(context, results); - } catch (e) { - return observer.onError(e); - } - observer.onNext(results); - } else { - if (results.length <= 1) { - observer.onNext.apply(observer, results); - } else { - observer.onNext(results); - } - } - observer.onCompleted(); - } - args.push(handler); - func.apply(context, args); - }).publishLast().refCount(); - }; - }; - Observable.fromNodeCallback = function(func, context, selector) { - return function() { - var len = arguments.length, - args = new Array(len); - for (var i = 0; i < len; i++) { - args[i] = arguments[i]; - } - return new AnonymousObservable(function(observer) { - function handler(err) { - if (err) { - observer.onError(err); - return ; - } - var len = arguments.length, - results = []; - for (var i = 1; i < len; i++) { - results[i - 1] = arguments[i]; - } - if (selector) { - try { - results = selector.apply(context, results); - } catch (e) { - return observer.onError(e); - } - observer.onNext(results); - } else { - if (results.length <= 1) { - observer.onNext.apply(observer, results); - } else { - observer.onNext(results); - } - } - observer.onCompleted(); - } - args.push(handler); - func.apply(context, args); - }).publishLast().refCount(); - }; - }; - function createListener(element, name, handler) { - if (element.addEventListener) { - element.addEventListener(name, handler, false); - return disposableCreate(function() { - element.removeEventListener(name, handler, false); - }); - } - throw new Error('No listener found'); + return _create(obj, proto); + }; + + Object.getOwnPropertyDescriptor = function (obj, prop) { + var desc = _getOwnPropertyDescriptor(obj, prop); + if (isUnconfigurable(obj, prop)) { + desc.configurable = false; } - function createEventListener(el, eventName, handler) { - var disposables = new CompositeDisposable(); - if (Object.prototype.toString.call(el) === '[object NodeList]') { - for (var i = 0, - len = el.length; i < len; i++) { - disposables.add(createEventListener(el.item(i), eventName, handler)); - } - } else if (el) { - disposables.add(createListener(el, eventName, handler)); - } - return disposables; - } - Rx.config.useNativeEvents = false; - Observable.fromEvent = function(element, eventName, selector) { - if (element.addListener) { - return fromEventPattern(function(h) { - element.addListener(eventName, h); - }, function(h) { - element.removeListener(eventName, h); - }, selector); - } - if (!Rx.config.useNativeEvents) { - if (typeof element.on === 'function' && typeof element.off === 'function') { - return fromEventPattern(function(h) { - element.on(eventName, h); - }, function(h) { - element.off(eventName, h); - }, selector); - } - } - return new AnonymousObservable(function(observer) { - return createEventListener(element, eventName, function handler(e) { - var results = e; - if (selector) { - try { - results = selector(arguments); - } catch (err) { - return observer.onError(err); - } - } - observer.onNext(results); - }); - }).publish().refCount(); - }; - var fromEventPattern = Observable.fromEventPattern = function(addHandler, removeHandler, selector) { - return new AnonymousObservable(function(observer) { - function innerHandler(e) { - var result = e; - if (selector) { - try { - result = selector(arguments); - } catch (err) { - return observer.onError(err); - } - } - observer.onNext(result); - } - var returnValue = addHandler(innerHandler); - return disposableCreate(function() { - if (removeHandler) { - removeHandler(innerHandler, returnValue); - } - }); - }).publish().refCount(); - }; - Observable.startAsync = function(functionAsync) { - var promise; - try { - promise = functionAsync(); - } catch (e) { - return observableThrow(e); - } - return observableFromPromise(promise); - }; - var PausableObservable = (function(__super__) { - inherits(PausableObservable, __super__); - function subscribe(observer) { - var conn = this.source.publish(), - subscription = conn.subscribe(observer), - connection = disposableEmpty; - var pausable = this.pauser.distinctUntilChanged().subscribe(function(b) { - if (b) { - connection = conn.connect(); - } else { - connection.dispose(); - connection = disposableEmpty; - } - }); - return new CompositeDisposable(subscription, connection, pausable); - } - function PausableObservable(source, pauser) { - this.source = source; - this.controller = new Subject(); - if (pauser && pauser.subscribe) { - this.pauser = this.controller.merge(pauser); - } else { - this.pauser = this.controller; - } - __super__.call(this, subscribe, source); - } - PausableObservable.prototype.pause = function() { - this.controller.onNext(false); - }; - PausableObservable.prototype.resume = function() { - this.controller.onNext(true); - }; - return PausableObservable; - }(Observable)); - observableProto.pausable = function(pauser) { - return new PausableObservable(this, pauser); - }; - function combineLatestSource(source, subject, resultSelector) { - return new AnonymousObservable(function(o) { - var hasValue = [false, false], - hasValueAll = false, - isDone = false, - values = new Array(2), - err; - function next(x, i) { - values[i] = x; - var res; - hasValue[i] = true; - if (hasValueAll || (hasValueAll = hasValue.every(identity))) { - if (err) { - o.onError(err); - return ; - } - try { - res = resultSelector.apply(null, values); - } catch (ex) { - o.onError(ex); - return ; - } - o.onNext(res); - } - if (isDone && values[1]) { - o.onCompleted(); - } - } - return new CompositeDisposable(source.subscribe(function(x) { - next(x, 0); - }, function(e) { - if (values[1]) { - o.onError(e); - } else { - err = e; - } - }, function() { - isDone = true; - values[1] && o.onCompleted(); - }), subject.subscribe(function(x) { - next(x, 1); - }, function(e) { - o.onError(e); - }, function() { - isDone = true; - next(true, 1); - })); - }, source); + return desc; + }; +}; + +function _redefineProperty(obj, prop, desc) { + desc = rewriteDescriptor(obj, prop, desc); + return _defineProperty(obj, prop, desc); +}; + +function isUnconfigurable (obj, prop) { + return obj && obj.__unconfigurables && obj.__unconfigurables[prop]; +} + +function rewriteDescriptor (obj, prop, desc) { + desc.configurable = true; + if (!desc.configurable) { + if (!obj.__unconfigurables) { + _defineProperty(obj, '__unconfigurables', { writable: true, value: {} }); } - var PausableBufferedObservable = (function(__super__) { - inherits(PausableBufferedObservable, __super__); - function subscribe(o) { - var q = [], - previousShouldFire; - var subscription = combineLatestSource(this.source, this.pauser.distinctUntilChanged().startWith(false), function(data, shouldFire) { - return { - data: data, - shouldFire: shouldFire - }; - }).subscribe(function(results) { - if (previousShouldFire !== undefined && results.shouldFire != previousShouldFire) { - previousShouldFire = results.shouldFire; - if (results.shouldFire) { - while (q.length > 0) { - o.onNext(q.shift()); - } - } - } else { - previousShouldFire = results.shouldFire; - if (results.shouldFire) { - o.onNext(results.data); - } else { - q.push(results.data); - } - } - }, function(err) { - while (q.length > 0) { - o.onNext(q.shift()); - } - o.onError(err); - }, function() { - while (q.length > 0) { - o.onNext(q.shift()); - } - o.onCompleted(); - }); - return subscription; - } - function PausableBufferedObservable(source, pauser) { - this.source = source; - this.controller = new Subject(); - if (pauser && pauser.subscribe) { - this.pauser = this.controller.merge(pauser); - } else { - this.pauser = this.controller; - } - __super__.call(this, subscribe, source); - } - PausableBufferedObservable.prototype.pause = function() { - this.controller.onNext(false); + obj.__unconfigurables[prop] = true; + } + return desc; +} + +module.exports = { + apply: apply, + _redefineProperty: _redefineProperty +}; + + + +},{}],7:[function(require,module,exports){ +(function (global){ +'use strict'; + +var utils = require('../utils'); + +function apply() { + // patched properties depend on addEventListener, so this needs to come first + if (global.EventTarget) { + utils.patchEventTargetMethods(global.EventTarget.prototype); + + // Note: EventTarget is not available in all browsers, + // if it's not available, we instead patch the APIs in the IDL that inherit from EventTarget + } else { + var apis = [ 'ApplicationCache', + 'EventSource', + 'FileReader', + 'InputMethodContext', + 'MediaController', + 'MessagePort', + 'Node', + 'Performance', + 'SVGElementInstance', + 'SharedWorker', + 'TextTrack', + 'TextTrackCue', + 'TextTrackList', + 'WebKitNamedFlow', + 'Window', + 'Worker', + 'WorkerGlobalScope', + 'XMLHttpRequestEventTarget', + 'XMLHttpRequestUpload' + ]; + + apis.forEach(function(thing) { + global[thing] && utils.patchEventTargetMethods(global[thing].prototype); + }); + } +} + +module.exports = { + apply: apply +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"../utils":14}],8:[function(require,module,exports){ +(function (global){ +'use strict'; + +var utils = require('../utils'); + +function patchSetClearFunction(obj, fnNames) { + fnNames.map(function (name) { + return name[0].toUpperCase() + name.substr(1); + }).forEach(function (name) { + var setName = 'set' + name; + var delegate = obj[setName]; + + if (delegate) { + var clearName = 'clear' + name; + var ids = {}; + + var bindArgs = setName === 'setInterval' ? utils.bindArguments : utils.bindArgumentsOnce; + + global.zone[setName] = function (fn) { + var id, fnRef = fn; + arguments[0] = function () { + delete ids[id]; + return fnRef.apply(this, arguments); + }; + var args = bindArgs(arguments); + id = delegate.apply(obj, args); + ids[id] = true; + return id; }; - PausableBufferedObservable.prototype.resume = function() { - this.controller.onNext(true); + + obj[setName] = function () { + return global.zone[setName].apply(this, arguments); }; - return PausableBufferedObservable; - }(Observable)); - observableProto.pausableBuffered = function(subject) { - return new PausableBufferedObservable(this, subject); - }; - var ControlledObservable = (function(__super__) { - inherits(ControlledObservable, __super__); - function subscribe(observer) { - return this.source.subscribe(observer); - } - function ControlledObservable(source, enableQueue) { - __super__.call(this, subscribe, source); - this.subject = new ControlledSubject(enableQueue); - this.source = source.multicast(this.subject).refCount(); - } - ControlledObservable.prototype.request = function(numberOfItems) { - if (numberOfItems == null) { - numberOfItems = -1; + + var clearDelegate = obj[clearName]; + + global.zone[clearName] = function (id) { + if (ids[id]) { + delete ids[id]; + global.zone.dequeueTask(); } - return this.subject.request(numberOfItems); + return clearDelegate.apply(this, arguments); }; - return ControlledObservable; - }(Observable)); - var ControlledSubject = (function(__super__) { - function subscribe(observer) { - return this.subject.subscribe(observer); - } - inherits(ControlledSubject, __super__); - function ControlledSubject(enableQueue) { - enableQueue == null && (enableQueue = true); - __super__.call(this, subscribe); - this.subject = new Subject(); - this.enableQueue = enableQueue; - this.queue = enableQueue ? [] : null; - this.requestedCount = 0; - this.requestedDisposable = disposableEmpty; - this.error = null; - this.hasFailed = false; - this.hasCompleted = false; - } - addProperties(ControlledSubject.prototype, Observer, { - onCompleted: function() { - this.hasCompleted = true; - if (!this.enableQueue || this.queue.length === 0) - this.subject.onCompleted(); - else - this.queue.push(Rx.Notification.createOnCompleted()); - }, - onError: function(error) { - this.hasFailed = true; - this.error = error; - if (!this.enableQueue || this.queue.length === 0) - this.subject.onError(error); - else - this.queue.push(Rx.Notification.createOnError(error)); - }, - onNext: function(value) { - var hasRequested = false; - if (this.requestedCount === 0) { - this.enableQueue && this.queue.push(Rx.Notification.createOnNext(value)); - } else { - (this.requestedCount !== -1 && this.requestedCount-- === 0) && this.disposeCurrentRequest(); - hasRequested = true; - } - hasRequested && this.subject.onNext(value); - }, - _processRequest: function(numberOfItems) { - if (this.enableQueue) { - while ((this.queue.length >= numberOfItems && numberOfItems > 0) || (this.queue.length > 0 && this.queue[0].kind !== 'N')) { - var first = this.queue.shift(); - first.accept(this.subject); - if (first.kind === 'N') - numberOfItems--; - else { - this.disposeCurrentRequest(); - this.queue = []; - } - } - return { - numberOfItems: numberOfItems, - returnValue: this.queue.length !== 0 - }; - } - return { - numberOfItems: numberOfItems, - returnValue: false - }; - }, - request: function(number) { - this.disposeCurrentRequest(); - var self = this, - r = this._processRequest(number); - var number = r.numberOfItems; - if (!r.returnValue) { - this.requestedCount = number; - this.requestedDisposable = disposableCreate(function() { - self.requestedCount = 0; - }); - return this.requestedDisposable; - } else { - return disposableEmpty; - } - }, - disposeCurrentRequest: function() { - this.requestedDisposable.dispose(); - this.requestedDisposable = disposableEmpty; - } - }); - return ControlledSubject; - }(Observable)); - observableProto.controlled = function(enableQueue) { - if (enableQueue == null) { - enableQueue = true; - } - return new ControlledObservable(this, enableQueue); - }; - var StopAndWaitObservable = (function(__super__) { - function subscribe(observer) { - this.subscription = this.source.subscribe(new StopAndWaitObserver(observer, this, this.subscription)); - var self = this; - timeoutScheduler.schedule(function() { - self.source.request(1); - }); - return this.subscription; - } - inherits(StopAndWaitObservable, __super__); - function StopAndWaitObservable(source) { - __super__.call(this, subscribe, source); - this.source = source; - } - var StopAndWaitObserver = (function(__sub__) { - inherits(StopAndWaitObserver, __sub__); - function StopAndWaitObserver(observer, observable, cancel) { - __sub__.call(this); - this.observer = observer; - this.observable = observable; - this.cancel = cancel; - } - var stopAndWaitObserverProto = StopAndWaitObserver.prototype; - stopAndWaitObserverProto.completed = function() { - this.observer.onCompleted(); - this.dispose(); - }; - stopAndWaitObserverProto.error = function(error) { - this.observer.onError(error); - this.dispose(); - }; - stopAndWaitObserverProto.next = function(value) { - this.observer.onNext(value); - var self = this; - timeoutScheduler.schedule(function() { - self.observable.source.request(1); - }); - }; - stopAndWaitObserverProto.dispose = function() { - this.observer = null; - if (this.cancel) { - this.cancel.dispose(); - this.cancel = null; - } - __sub__.prototype.dispose.call(this); - }; - return StopAndWaitObserver; - }(AbstractObserver)); - return StopAndWaitObservable; - }(Observable)); - ControlledObservable.prototype.stopAndWait = function() { - return new StopAndWaitObservable(this); - }; - var WindowedObservable = (function(__super__) { - function subscribe(observer) { - this.subscription = this.source.subscribe(new WindowedObserver(observer, this, this.subscription)); - var self = this; - timeoutScheduler.schedule(function() { - self.source.request(self.windowSize); - }); - return this.subscription; - } - inherits(WindowedObservable, __super__); - function WindowedObservable(source, windowSize) { - __super__.call(this, subscribe, source); - this.source = source; - this.windowSize = windowSize; - } - var WindowedObserver = (function(__sub__) { - inherits(WindowedObserver, __sub__); - function WindowedObserver(observer, observable, cancel) { - this.observer = observer; - this.observable = observable; - this.cancel = cancel; - this.received = 0; - } - var windowedObserverPrototype = WindowedObserver.prototype; - windowedObserverPrototype.completed = function() { - this.observer.onCompleted(); - this.dispose(); - }; - windowedObserverPrototype.error = function(error) { - this.observer.onError(error); - this.dispose(); - }; - windowedObserverPrototype.next = function(value) { - this.observer.onNext(value); - this.received = ++this.received % this.observable.windowSize; - if (this.received === 0) { - var self = this; - timeoutScheduler.schedule(function() { - self.observable.source.request(self.observable.windowSize); - }); - } - }; - windowedObserverPrototype.dispose = function() { - this.observer = null; - if (this.cancel) { - this.cancel.dispose(); - this.cancel = null; - } - __sub__.prototype.dispose.call(this); - }; - return WindowedObserver; - }(AbstractObserver)); - return WindowedObservable; - }(Observable)); - ControlledObservable.prototype.windowed = function(windowSize) { - return new WindowedObservable(this, windowSize); - }; - observableProto.pipe = function(dest) { - var source = this.pausableBuffered(); - function onDrain() { - source.resume(); - } - dest.addListener('drain', onDrain); - source.subscribe(function(x) { - !dest.write(String(x)) && source.pause(); - }, function(err) { - dest.emit('error', err); - }, function() { - !dest._isStdio && dest.end(); - dest.removeListener('drain', onDrain); - }); - source.resume(); - return dest; - }; - observableProto.multicast = function(subjectOrSubjectSelector, selector) { - var source = this; - return typeof subjectOrSubjectSelector === 'function' ? new AnonymousObservable(function(observer) { - var connectable = source.multicast(subjectOrSubjectSelector()); - return new CompositeDisposable(selector(connectable).subscribe(observer), connectable.connect()); - }, source) : new ConnectableObservable(source, subjectOrSubjectSelector); - }; - observableProto.publish = function(selector) { - return selector && isFunction(selector) ? this.multicast(function() { - return new Subject(); - }, selector) : this.multicast(new Subject()); - }; - observableProto.share = function() { - return this.publish().refCount(); - }; - observableProto.publishLast = function(selector) { - return selector && isFunction(selector) ? this.multicast(function() { - return new AsyncSubject(); - }, selector) : this.multicast(new AsyncSubject()); - }; - observableProto.publishValue = function(initialValueOrSelector, initialValue) { - return arguments.length === 2 ? this.multicast(function() { - return new BehaviorSubject(initialValue); - }, initialValueOrSelector) : this.multicast(new BehaviorSubject(initialValueOrSelector)); - }; - observableProto.shareValue = function(initialValue) { - return this.publishValue(initialValue).refCount(); - }; - observableProto.replay = function(selector, bufferSize, windowSize, scheduler) { - return selector && isFunction(selector) ? this.multicast(function() { - return new ReplaySubject(bufferSize, windowSize, scheduler); - }, selector) : this.multicast(new ReplaySubject(bufferSize, windowSize, scheduler)); - }; - observableProto.shareReplay = function(bufferSize, windowSize, scheduler) { - return this.replay(null, bufferSize, windowSize, scheduler).refCount(); - }; - var InnerSubscription = function(subject, observer) { - this.subject = subject; - this.observer = observer; - }; - InnerSubscription.prototype.dispose = function() { - if (!this.subject.isDisposed && this.observer !== null) { - var idx = this.subject.observers.indexOf(this.observer); - this.subject.observers.splice(idx, 1); - this.observer = null; - } - }; - var BehaviorSubject = Rx.BehaviorSubject = (function(__super__) { - function subscribe(observer) { - checkDisposed(this); - if (!this.isStopped) { - this.observers.push(observer); - observer.onNext(this.value); - return new InnerSubscription(this, observer); - } - if (this.hasError) { - observer.onError(this.error); - } else { - observer.onCompleted(); - } - return disposableEmpty; - } - inherits(BehaviorSubject, __super__); - function BehaviorSubject(value) { - __super__.call(this, subscribe); - this.value = value, this.observers = [], this.isDisposed = false, this.isStopped = false, this.hasError = false; - } - addProperties(BehaviorSubject.prototype, Observer, { - getValue: function() { - checkDisposed(this); - if (this.hasError) { - throw this.error; - } - return this.value; - }, - hasObservers: function() { - return this.observers.length > 0; - }, - onCompleted: function() { - checkDisposed(this); - if (this.isStopped) { - return ; - } - this.isStopped = true; - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - os[i].onCompleted(); - } - this.observers.length = 0; - }, - onError: function(error) { - checkDisposed(this); - if (this.isStopped) { - return ; - } - this.isStopped = true; - this.hasError = true; - this.error = error; - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - os[i].onError(error); - } - this.observers.length = 0; - }, - onNext: function(value) { - checkDisposed(this); - if (this.isStopped) { - return ; - } - this.value = value; - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - os[i].onNext(value); - } - }, - dispose: function() { - this.isDisposed = true; - this.observers = null; - this.value = null; - this.exception = null; - } - }); - return BehaviorSubject; - }(Observable)); - var ReplaySubject = Rx.ReplaySubject = (function(__super__) { - var maxSafeInteger = Math.pow(2, 53) - 1; - function createRemovableDisposable(subject, observer) { - return disposableCreate(function() { - observer.dispose(); - !subject.isDisposed && subject.observers.splice(subject.observers.indexOf(observer), 1); - }); - } - function subscribe(observer) { - var so = new ScheduledObserver(this.scheduler, observer), - subscription = createRemovableDisposable(this, so); - checkDisposed(this); - this._trim(this.scheduler.now()); - this.observers.push(so); - for (var i = 0, - len = this.q.length; i < len; i++) { - so.onNext(this.q[i].value); - } - if (this.hasError) { - so.onError(this.error); - } else if (this.isStopped) { - so.onCompleted(); - } - so.ensureActive(); - return subscription; - } - inherits(ReplaySubject, __super__); - function ReplaySubject(bufferSize, windowSize, scheduler) { - this.bufferSize = bufferSize == null ? maxSafeInteger : bufferSize; - this.windowSize = windowSize == null ? maxSafeInteger : windowSize; - this.scheduler = scheduler || currentThreadScheduler; - this.q = []; - this.observers = []; - this.isStopped = false; - this.isDisposed = false; - this.hasError = false; - this.error = null; - __super__.call(this, subscribe); - } - addProperties(ReplaySubject.prototype, Observer.prototype, { - hasObservers: function() { - return this.observers.length > 0; - }, - _trim: function(now) { - while (this.q.length > this.bufferSize) { - this.q.shift(); - } - while (this.q.length > 0 && (now - this.q[0].interval) > this.windowSize) { - this.q.shift(); - } - }, - onNext: function(value) { - checkDisposed(this); - if (this.isStopped) { - return ; - } - var now = this.scheduler.now(); - this.q.push({ - interval: now, - value: value - }); - this._trim(now); - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - var observer = os[i]; - observer.onNext(value); - observer.ensureActive(); - } - }, - onError: function(error) { - checkDisposed(this); - if (this.isStopped) { - return ; - } - this.isStopped = true; - this.error = error; - this.hasError = true; - var now = this.scheduler.now(); - this._trim(now); - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - var observer = os[i]; - observer.onError(error); - observer.ensureActive(); - } - this.observers.length = 0; - }, - onCompleted: function() { - checkDisposed(this); - if (this.isStopped) { - return ; - } - this.isStopped = true; - var now = this.scheduler.now(); - this._trim(now); - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - var observer = os[i]; - observer.onCompleted(); - observer.ensureActive(); - } - this.observers.length = 0; - }, - dispose: function() { - this.isDisposed = true; - this.observers = null; - } - }); - return ReplaySubject; - }(Observable)); - var ConnectableObservable = Rx.ConnectableObservable = (function(__super__) { - inherits(ConnectableObservable, __super__); - function ConnectableObservable(source, subject) { - var hasSubscription = false, - subscription, - sourceObservable = source.asObservable(); - this.connect = function() { - if (!hasSubscription) { - hasSubscription = true; - subscription = new CompositeDisposable(sourceObservable.subscribe(subject), disposableCreate(function() { - hasSubscription = false; - })); - } - return subscription; - }; - __super__.call(this, function(o) { - return subject.subscribe(o); - }); - } - ConnectableObservable.prototype.refCount = function() { - var connectableSubscription, - count = 0, - source = this; - return new AnonymousObservable(function(observer) { - var shouldConnect = ++count === 1, - subscription = source.subscribe(observer); - shouldConnect && (connectableSubscription = source.connect()); - return function() { - subscription.dispose(); - --count === 0 && connectableSubscription.dispose(); - }; - }); + + obj[clearName] = function () { + return global.zone[clearName].apply(this, arguments); + }; + } + }); +}; + +function patchSetFunction(obj, fnNames) { + fnNames.forEach(function (name) { + var delegate = obj[name]; + + if (delegate) { + global.zone[name] = function (fn) { + var fnRef = fn; + arguments[0] = function () { + return fnRef.apply(this, arguments); + }; + var args = utils.bindArgumentsOnce(arguments); + return delegate.apply(obj, args); }; - return ConnectableObservable; - }(Observable)); - var Dictionary = (function() { - var primes = [1, 3, 7, 13, 31, 61, 127, 251, 509, 1021, 2039, 4093, 8191, 16381, 32749, 65521, 131071, 262139, 524287, 1048573, 2097143, 4194301, 8388593, 16777213, 33554393, 67108859, 134217689, 268435399, 536870909, 1073741789, 2147483647], - noSuchkey = "no such key", - duplicatekey = "duplicate key"; - function isPrime(candidate) { - if ((candidate & 1) === 0) { - return candidate === 2; - } - var num1 = Math.sqrt(candidate), - num2 = 3; - while (num2 <= num1) { - if (candidate % num2 === 0) { - return false; - } - num2 += 2; - } - return true; + + obj[name] = function () { + return zone[name].apply(this, arguments); + }; + } + }); +}; + +function patchFunction(obj, fnNames) { + fnNames.forEach(function (name) { + var delegate = obj[name]; + global.zone[name] = function () { + return delegate.apply(obj, arguments); + }; + + obj[name] = function () { + return global.zone[name].apply(this, arguments); + }; + }); +}; + + +module.exports = { + patchSetClearFunction: patchSetClearFunction, + patchSetFunction: patchSetFunction, + patchFunction: patchFunction +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"../utils":14}],9:[function(require,module,exports){ +(function (global){ +'use strict'; + +// wrap some native API on `window` +function patchClass(className) { + var OriginalClass = global[className]; + if (!OriginalClass) return; + + global[className] = function (fn) { + this._o = new OriginalClass(global.zone.bind(fn, true)); + // Remember where the class was instantiate to execute the enqueueTask and dequeueTask hooks + this._creationZone = global.zone; + }; + + var instance = new OriginalClass(function () {}); + + global[className].prototype.disconnect = function () { + var result = this._o.disconnect.apply(this._o, arguments); + if (this._active) { + this._creationZone.dequeueTask(); + this._active = false; + } + return result; + }; + + global[className].prototype.observe = function () { + if (!this._active) { + this._creationZone.enqueueTask(); + this._active = true; + } + return this._o.observe.apply(this._o, arguments); + }; + + var prop; + for (prop in instance) { + (function (prop) { + if (typeof global[className].prototype !== undefined) { + return; } - function getPrime(min) { - var index, - num, - candidate; - for (index = 0; index < primes.length; ++index) { - num = primes[index]; - if (num >= min) { - return num; + if (typeof instance[prop] === 'function') { + global[className].prototype[prop] = function () { + return this._o[prop].apply(this._o, arguments); + }; + } else { + Object.defineProperty(global[className].prototype, prop, { + set: function (fn) { + if (typeof fn === 'function') { + this._o[prop] = global.zone.bind(fn); + } else { + this._o[prop] = fn; + } + }, + get: function () { + return this._o[prop]; } + }); + } + }(prop)); + } +}; + +module.exports = { + patchClass: patchClass +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}],10:[function(require,module,exports){ +(function (global){ +'use strict'; + +var utils = require('../utils'); + +/* + * patch a fn that returns a promise + */ +var bindPromiseFn = (function() { + // if the browser natively supports Promises, we can just return a native promise + if (global.Promise) { + return function (delegate) { + return function() { + var delegatePromise = delegate.apply(this, arguments); + if (delegatePromise instanceof Promise) { + return delegatePromise; + } else { + return new Promise(function(resolve, reject) { + delegatePromise.then(resolve, reject); + }); } - candidate = min | 1; - while (candidate < primes[primes.length - 1]) { - if (isPrime(candidate)) { - return candidate; - } - candidate += 2; + }; + }; + } else { + // if the browser does not have native promises, we have to patch each promise instance + return function (delegate) { + return function () { + return patchThenable(delegate.apply(this, arguments)); + }; + }; + } + + function patchThenable(thenable) { + var then = thenable.then; + thenable.then = function () { + var args = utils.bindArguments(arguments); + var nextThenable = then.apply(thenable, args); + return patchThenable(nextThenable); + }; + + var ocatch = thenable.catch; + thenable.catch = function () { + var args = utils.bindArguments(arguments); + var nextThenable = ocatch.apply(thenable, args); + return patchThenable(nextThenable); + }; + return thenable; + } +}()); + +function apply() { + if (global.Promise) { + utils.patchPrototype(Promise.prototype, [ + 'then', + 'catch' + ]); + } +} + +module.exports = { + apply: apply, + bindPromiseFn: bindPromiseFn +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"../utils":14}],11:[function(require,module,exports){ +(function (global){ +'use strict'; + +var webSocketPatch = require('./websocket'); +var utils = require('../utils'); + +var eventNames = 'copy cut paste abort blur focus canplay canplaythrough change click contextmenu dblclick drag dragend dragenter dragleave dragover dragstart drop durationchange emptied ended input invalid keydown keypress keyup load loadeddata loadedmetadata loadstart message mousedown mouseenter mouseleave mousemove mouseout mouseover mouseup pause play playing progress ratechange reset scroll seeked seeking select show stalled submit suspend timeupdate volumechange waiting mozfullscreenchange mozfullscreenerror mozpointerlockchange mozpointerlockerror error webglcontextrestored webglcontextlost webglcontextcreationerror'.split(' '); + +function apply() { + if (canPatchViaPropertyDescriptor()) { + // for browsers that we can patch the descriptor: Chrome & Firefox + var onEventNames = eventNames.map(function (property) { + return 'on' + property; + }); + utils.patchProperties(HTMLElement.prototype, onEventNames); + utils.patchProperties(XMLHttpRequest.prototype); + utils.patchProperties(WebSocket.prototype); + } else { + // Safari + patchViaCapturingAllTheEvents(); + utils.patchClass('XMLHttpRequest'); + webSocketPatch.apply(); + } +} + +function canPatchViaPropertyDescriptor() { + if (!Object.getOwnPropertyDescriptor(HTMLElement.prototype, 'onclick') && typeof Element !== 'undefined') { + // WebKit https://bugs.webkit.org/show_bug.cgi?id=134364 + // IDL interface attributes are not configurable + var desc = Object.getOwnPropertyDescriptor(Element.prototype, 'onclick'); + if (desc && !desc.configurable) return false; + } + + Object.defineProperty(HTMLElement.prototype, 'onclick', { + get: function () { + return true; + } + }); + var elt = document.createElement('div'); + var result = !!elt.onclick; + Object.defineProperty(HTMLElement.prototype, 'onclick', {}); + return result; +}; + +// Whenever any event fires, we check the event target and all parents +// for `onwhatever` properties and replace them with zone-bound functions +// - Chrome (for now) +function patchViaCapturingAllTheEvents() { + eventNames.forEach(function (property) { + var onproperty = 'on' + property; + document.addEventListener(property, function (event) { + var elt = event.target, bound; + while (elt) { + if (elt[onproperty] && !elt[onproperty]._unbound) { + bound = global.zone.bind(elt[onproperty]); + bound._unbound = elt[onproperty]; + elt[onproperty] = bound; } - return min; + elt = elt.parentElement; } - function stringHashFn(str) { - var hash = 757602046; - if (!str.length) { - return hash; - } - for (var i = 0, - len = str.length; i < len; i++) { - var character = str.charCodeAt(i); - hash = ((hash << 5) - hash) + character; - hash = hash & hash; + }, true); + }); +}; + +module.exports = { + apply: apply +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"../utils":14,"./websocket":13}],12:[function(require,module,exports){ +(function (global){ +'use strict'; + +var _redefineProperty = require('./define-property')._redefineProperty; + +function apply() { + if (!('registerElement' in global.document)) { + return; + } + + var _registerElement = document.registerElement; + var callbacks = [ + 'createdCallback', + 'attachedCallback', + 'detachedCallback', + 'attributeChangedCallback' + ]; + + document.registerElement = function (name, opts) { + callbacks.forEach(function (callback) { + if (opts.prototype[callback]) { + var descriptor = Object.getOwnPropertyDescriptor(opts.prototype, callback); + if (descriptor.value) { + descriptor.value = global.zone.bind(descriptor.value || opts.prototype[callback]); + _redefineProperty(opts.prototype, callback, descriptor); } - return hash; } - function numberHashFn(key) { - var c2 = 0x27d4eb2d; - key = (key ^ 61) ^ (key >>> 16); - key = key + (key << 3); - key = key ^ (key >>> 4); - key = key * c2; - key = key ^ (key >>> 15); - return key; + }); + return _registerElement.apply(document, [name, opts]); + }; +} + +module.exports = { + apply: apply +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"./define-property":6}],13:[function(require,module,exports){ +(function (global){ +'use strict'; + +var utils = require('../utils.js'); + +// we have to patch the instance since the proto is non-configurable +function apply() { + var WS = global.WebSocket; + utils.patchEventTargetMethods(WS.prototype); + global.WebSocket = function(a, b) { + var socket = arguments.length > 1 ? new WS(a, b) : new WS(a); + var proxySocket; + + // Safari 7.0 has non-configurable own 'onmessage' and friends properties on the socket instance + var onmessageDesc = Object.getOwnPropertyDescriptor(socket, 'onmessage'); + if (onmessageDesc && onmessageDesc.configurable === false) { + proxySocket = Object.create(socket); + ['addEventListener', 'removeEventListener', 'send', 'close'].forEach(function(propName) { + proxySocket[propName] = function() { + return socket[propName].apply(socket, arguments); + }; + }); + } else { + // we can patch the real socket + proxySocket = socket; + } + + utils.patchProperties(proxySocket, ['onclose', 'onerror', 'onmessage', 'onopen']); + + return proxySocket; + }; +} + +module.exports = { + apply: apply +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{"../utils.js":14}],14:[function(require,module,exports){ +(function (global){ +'use strict'; + +function bindArguments(args) { + for (var i = args.length - 1; i >= 0; i--) { + if (typeof args[i] === 'function') { + args[i] = global.zone.bind(args[i]); + } + } + return args; +}; + +function bindArgumentsOnce(args) { + for (var i = args.length - 1; i >= 0; i--) { + if (typeof args[i] === 'function') { + args[i] = global.zone.bindOnce(args[i]); + } + } + return args; +}; + +function patchPrototype(obj, fnNames) { + fnNames.forEach(function (name) { + var delegate = obj[name]; + if (delegate) { + obj[name] = function () { + return delegate.apply(this, bindArguments(arguments)); + }; + } + }); +}; + +function patchProperty(obj, prop) { + var desc = Object.getOwnPropertyDescriptor(obj, prop) || { + enumerable: true, + configurable: true + }; + + // A property descriptor cannot have getter/setter and be writable + // deleting the writable and value properties avoids this error: + // + // TypeError: property descriptors must not specify a value or be writable when a + // getter or setter has been specified + delete desc.writable; + delete desc.value; + + // substr(2) cuz 'onclick' -> 'click', etc + var eventName = prop.substr(2); + var _prop = '_' + prop; + + desc.set = function (fn) { + if (this[_prop]) { + this.removeEventListener(eventName, this[_prop]); + } + + if (typeof fn === 'function') { + this[_prop] = fn; + this.addEventListener(eventName, fn, false); + } else { + this[_prop] = null; + } + }; + + desc.get = function () { + return this[_prop]; + }; + + Object.defineProperty(obj, prop, desc); +}; + +function patchProperties(obj, properties) { + + (properties || (function () { + var props = []; + for (var prop in obj) { + props.push(prop); } - var getHashCode = (function() { - var uniqueIdCounter = 0; - return function(obj) { - if (obj == null) { - throw new Error(noSuchkey); - } - if (typeof obj === 'string') { - return stringHashFn(obj); - } - if (typeof obj === 'number') { - return numberHashFn(obj); - } - if (typeof obj === 'boolean') { - return obj === true ? 1 : 0; - } - if (obj instanceof Date) { - return numberHashFn(obj.valueOf()); - } - if (obj instanceof RegExp) { - return stringHashFn(obj.toString()); - } - if (typeof obj.valueOf === 'function') { - var valueOf = obj.valueOf(); - if (typeof valueOf === 'number') { - return numberHashFn(valueOf); - } - if (typeof valueOf === 'string') { - return stringHashFn(valueOf); - } - } - if (obj.hashCode) { - return obj.hashCode(); - } - var id = 17 * uniqueIdCounter++; - obj.hashCode = function() { - return id; - }; - return id; - }; - }()); - function newEntry() { - return { - key: null, - value: null, - next: 0, - hashCode: 0 + return props; + }()). + filter(function (propertyName) { + return propertyName.substr(0,2) === 'on'; + })). + forEach(function (eventName) { + patchProperty(obj, eventName); + }); +}; + +function patchEventTargetMethods(obj) { + var addDelegate = obj.addEventListener; + obj.addEventListener = function (eventName, fn) { + fn._bound = fn._bound || {}; + arguments[1] = fn._bound[eventName] = zone.bind(fn); + return addDelegate.apply(this, arguments); + }; + + var removeDelegate = obj.removeEventListener; + obj.removeEventListener = function (eventName, fn) { + if(arguments[1]._bound && arguments[1]._bound[eventName]) { + var _bound = arguments[1]._bound; + arguments[1] = _bound[eventName]; + delete _bound[eventName]; + } + var result = removeDelegate.apply(this, arguments); + global.zone.dequeueTask(fn); + return result; + }; +}; + +// wrap some native API on `window` +function patchClass(className) { + var OriginalClass = global[className]; + if (!OriginalClass) return; + + global[className] = function () { + var a = bindArguments(arguments); + switch (a.length) { + case 0: this._o = new OriginalClass(); break; + case 1: this._o = new OriginalClass(a[0]); break; + case 2: this._o = new OriginalClass(a[0], a[1]); break; + case 3: this._o = new OriginalClass(a[0], a[1], a[2]); break; + case 4: this._o = new OriginalClass(a[0], a[1], a[2], a[3]); break; + default: throw new Error('what are you even doing?'); + } + }; + + var instance = new OriginalClass(className.substr(-16) === 'MutationObserver' ? function () {} : undefined); + + var prop; + for (prop in instance) { + (function (prop) { + if (typeof instance[prop] === 'function') { + global[className].prototype[prop] = function () { + return this._o[prop].apply(this._o, arguments); }; - } - function Dictionary(capacity, comparer) { - if (capacity < 0) { - throw new ArgumentOutOfRangeError(); - } - if (capacity > 0) { - this._initialize(capacity); - } - this.comparer = comparer || defaultComparer; - this.freeCount = 0; - this.size = 0; - this.freeList = -1; - } - var dictionaryProto = Dictionary.prototype; - dictionaryProto._initialize = function(capacity) { - var prime = getPrime(capacity), - i; - this.buckets = new Array(prime); - this.entries = new Array(prime); - for (i = 0; i < prime; i++) { - this.buckets[i] = -1; - this.entries[i] = newEntry(); - } - this.freeList = -1; - }; - dictionaryProto.add = function(key, value) { - this._insert(key, value, true); - }; - dictionaryProto._insert = function(key, value, add) { - if (!this.buckets) { - this._initialize(0); - } - var index3, - num = getHashCode(key) & 2147483647, - index1 = num % this.buckets.length; - for (var index2 = this.buckets[index1]; index2 >= 0; index2 = this.entries[index2].next) { - if (this.entries[index2].hashCode === num && this.comparer(this.entries[index2].key, key)) { - if (add) { - throw new Error(duplicatekey); - } - this.entries[index2].value = value; - return ; - } - } - if (this.freeCount > 0) { - index3 = this.freeList; - this.freeList = this.entries[index3].next; - --this.freeCount; - } else { - if (this.size === this.entries.length) { - this._resize(); - index1 = num % this.buckets.length; - } - index3 = this.size; - ++this.size; - } - this.entries[index3].hashCode = num; - this.entries[index3].next = this.buckets[index1]; - this.entries[index3].key = key; - this.entries[index3].value = value; - this.buckets[index1] = index3; - }; - dictionaryProto._resize = function() { - var prime = getPrime(this.size * 2), - numArray = new Array(prime); - for (index = 0; index < numArray.length; ++index) { - numArray[index] = -1; - } - var entryArray = new Array(prime); - for (index = 0; index < this.size; ++index) { - entryArray[index] = this.entries[index]; - } - for (var index = this.size; index < prime; ++index) { - entryArray[index] = newEntry(); - } - for (var index1 = 0; index1 < this.size; ++index1) { - var index2 = entryArray[index1].hashCode % prime; - entryArray[index1].next = numArray[index2]; - numArray[index2] = index1; - } - this.buckets = numArray; - this.entries = entryArray; - }; - dictionaryProto.remove = function(key) { - if (this.buckets) { - var num = getHashCode(key) & 2147483647, - index1 = num % this.buckets.length, - index2 = -1; - for (var index3 = this.buckets[index1]; index3 >= 0; index3 = this.entries[index3].next) { - if (this.entries[index3].hashCode === num && this.comparer(this.entries[index3].key, key)) { - if (index2 < 0) { - this.buckets[index1] = this.entries[index3].next; - } else { - this.entries[index2].next = this.entries[index3].next; - } - this.entries[index3].hashCode = -1; - this.entries[index3].next = this.freeList; - this.entries[index3].key = null; - this.entries[index3].value = null; - this.freeList = index3; - ++this.freeCount; - return true; + } else { + Object.defineProperty(global[className].prototype, prop, { + set: function (fn) { + if (typeof fn === 'function') { + this._o[prop] = global.zone.bind(fn); } else { - index2 = index3; - } - } - } - return false; - }; - dictionaryProto.clear = function() { - var index, - len; - if (this.size <= 0) { - return ; - } - for (index = 0, len = this.buckets.length; index < len; ++index) { - this.buckets[index] = -1; - } - for (index = 0; index < this.size; ++index) { - this.entries[index] = newEntry(); - } - this.freeList = -1; - this.size = 0; - }; - dictionaryProto._findEntry = function(key) { - if (this.buckets) { - var num = getHashCode(key) & 2147483647; - for (var index = this.buckets[num % this.buckets.length]; index >= 0; index = this.entries[index].next) { - if (this.entries[index].hashCode === num && this.comparer(this.entries[index].key, key)) { - return index; - } - } - } - return -1; - }; - dictionaryProto.count = function() { - return this.size - this.freeCount; - }; - dictionaryProto.tryGetValue = function(key) { - var entry = this._findEntry(key); - return entry >= 0 ? this.entries[entry].value : undefined; - }; - dictionaryProto.getValues = function() { - var index = 0, - results = []; - if (this.entries) { - for (var index1 = 0; index1 < this.size; index1++) { - if (this.entries[index1].hashCode >= 0) { - results[index++] = this.entries[index1].value; - } - } - } - return results; - }; - dictionaryProto.get = function(key) { - var entry = this._findEntry(key); - if (entry >= 0) { - return this.entries[entry].value; - } - throw new Error(noSuchkey); - }; - dictionaryProto.set = function(key, value) { - this._insert(key, value, false); - }; - dictionaryProto.containskey = function(key) { - return this._findEntry(key) >= 0; - }; - return Dictionary; - }()); - observableProto.join = function(right, leftDurationSelector, rightDurationSelector, resultSelector) { - var left = this; - return new AnonymousObservable(function(observer) { - var group = new CompositeDisposable(); - var leftDone = false, - rightDone = false; - var leftId = 0, - rightId = 0; - var leftMap = new Dictionary(), - rightMap = new Dictionary(); - group.add(left.subscribe(function(value) { - var id = leftId++; - var md = new SingleAssignmentDisposable(); - leftMap.add(id, value); - group.add(md); - var expire = function() { - leftMap.remove(id) && leftMap.count() === 0 && leftDone && observer.onCompleted(); - group.remove(md); - }; - var duration; - try { - duration = leftDurationSelector(value); - } catch (e) { - observer.onError(e); - return ; - } - md.setDisposable(duration.take(1).subscribe(noop, observer.onError.bind(observer), expire)); - rightMap.getValues().forEach(function(v) { - var result; - try { - result = resultSelector(value, v); - } catch (exn) { - observer.onError(exn); - return ; - } - observer.onNext(result); - }); - }, observer.onError.bind(observer), function() { - leftDone = true; - (rightDone || leftMap.count() === 0) && observer.onCompleted(); - })); - group.add(right.subscribe(function(value) { - var id = rightId++; - var md = new SingleAssignmentDisposable(); - rightMap.add(id, value); - group.add(md); - var expire = function() { - rightMap.remove(id) && rightMap.count() === 0 && rightDone && observer.onCompleted(); - group.remove(md); - }; - var duration; - try { - duration = rightDurationSelector(value); - } catch (e) { - observer.onError(e); - return ; - } - md.setDisposable(duration.take(1).subscribe(noop, observer.onError.bind(observer), expire)); - leftMap.getValues().forEach(function(v) { - var result; - try { - result = resultSelector(v, value); - } catch (exn) { - observer.onError(exn); - return ; + this._o[prop] = fn; } - observer.onNext(result); - }); - }, observer.onError.bind(observer), function() { - rightDone = true; - (leftDone || rightMap.count() === 0) && observer.onCompleted(); - })); - return group; - }, left); - }; - observableProto.groupJoin = function(right, leftDurationSelector, rightDurationSelector, resultSelector) { - var left = this; - return new AnonymousObservable(function(observer) { - var group = new CompositeDisposable(); - var r = new RefCountDisposable(group); - var leftMap = new Dictionary(), - rightMap = new Dictionary(); - var leftId = 0, - rightId = 0; - function handleError(e) { - return function(v) { - v.onError(e); - }; - } - ; - group.add(left.subscribe(function(value) { - var s = new Subject(); - var id = leftId++; - leftMap.add(id, s); - var result; - try { - result = resultSelector(value, addRef(s, r)); - } catch (e) { - leftMap.getValues().forEach(handleError(e)); - observer.onError(e); - return ; - } - observer.onNext(result); - rightMap.getValues().forEach(function(v) { - s.onNext(v); - }); - var md = new SingleAssignmentDisposable(); - group.add(md); - var expire = function() { - leftMap.remove(id) && s.onCompleted(); - group.remove(md); - }; - var duration; - try { - duration = leftDurationSelector(value); - } catch (e) { - leftMap.getValues().forEach(handleError(e)); - observer.onError(e); - return ; - } - md.setDisposable(duration.take(1).subscribe(noop, function(e) { - leftMap.getValues().forEach(handleError(e)); - observer.onError(e); - }, expire)); - }, function(e) { - leftMap.getValues().forEach(handleError(e)); - observer.onError(e); - }, observer.onCompleted.bind(observer))); - group.add(right.subscribe(function(value) { - var id = rightId++; - rightMap.add(id, value); - var md = new SingleAssignmentDisposable(); - group.add(md); - var expire = function() { - rightMap.remove(id); - group.remove(md); - }; - var duration; - try { - duration = rightDurationSelector(value); - } catch (e) { - leftMap.getValues().forEach(handleError(e)); - observer.onError(e); - return ; + }, + get: function () { + return this._o[prop]; } - md.setDisposable(duration.take(1).subscribe(noop, function(e) { - leftMap.getValues().forEach(handleError(e)); - observer.onError(e); - }, expire)); - leftMap.getValues().forEach(function(v) { - v.onNext(value); - }); - }, function(e) { - leftMap.getValues().forEach(handleError(e)); - observer.onError(e); - })); - return r; - }, left); - }; - observableProto.buffer = function(bufferOpeningsOrClosingSelector, bufferClosingSelector) { - return this.window.apply(this, arguments).selectMany(function(x) { - return x.toArray(); - }); - }; - observableProto.window = function(windowOpeningsOrClosingSelector, windowClosingSelector) { - if (arguments.length === 1 && typeof arguments[0] !== 'function') { - return observableWindowWithBoundaries.call(this, windowOpeningsOrClosingSelector); + }); } - return typeof windowOpeningsOrClosingSelector === 'function' ? observableWindowWithClosingSelector.call(this, windowOpeningsOrClosingSelector) : observableWindowWithOpenings.call(this, windowOpeningsOrClosingSelector, windowClosingSelector); - }; - function observableWindowWithOpenings(windowOpenings, windowClosingSelector) { - return windowOpenings.groupJoin(this, windowClosingSelector, observableEmpty, function(_, win) { - return win; - }); + }(prop)); + }; +}; + +module.exports = { + bindArguments: bindArguments, + bindArgumentsOnce: bindArgumentsOnce, + patchPrototype: patchPrototype, + patchProperty: patchProperty, + patchProperties: patchProperties, + patchEventTargetMethods: patchEventTargetMethods, + patchClass: patchClass +}; + +}).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {}) +},{}]},{},[1]); + +/* + * Wrapped stacktrace + * + * We need this because in some implementations, constructing a trace is slow + * and so we want to defer accessing the trace for as long as possible + */ +Zone.Stacktrace = function (e) { + this._e = e; +}; +Zone.Stacktrace.prototype.get = function () { + if (zone.stackFramesFilter) { + return this._e.stack. + split('\n'). + filter(zone.stackFramesFilter). + join('\n'); + } + return this._e.stack; +} + +Zone.getStacktrace = function () { + function getStacktraceWithUncaughtError () { + return new Zone.Stacktrace(new Error()); + } + + function getStacktraceWithCaughtError () { + try { + throw new Error(); + } catch (e) { + return new Zone.Stacktrace(e); } - function observableWindowWithBoundaries(windowBoundaries) { - var source = this; - return new AnonymousObservable(function(observer) { - var win = new Subject(), - d = new CompositeDisposable(), - r = new RefCountDisposable(d); - observer.onNext(addRef(win, r)); - d.add(source.subscribe(function(x) { - win.onNext(x); - }, function(err) { - win.onError(err); - observer.onError(err); - }, function() { - win.onCompleted(); - observer.onCompleted(); - })); - isPromise(windowBoundaries) && (windowBoundaries = observableFromPromise(windowBoundaries)); - d.add(windowBoundaries.subscribe(function(w) { - win.onCompleted(); - win = new Subject(); - observer.onNext(addRef(win, r)); - }, function(err) { - win.onError(err); - observer.onError(err); - }, function() { - win.onCompleted(); - observer.onCompleted(); - })); - return r; - }, source); + } + + // Some implementations of exception handling don't create a stack trace if the exception + // isn't thrown, however it's faster not to actually throw the exception. + var stack = getStacktraceWithUncaughtError(); + if (stack && stack._e.stack) { + Zone.getStacktrace = getStacktraceWithUncaughtError; + return stack; + } else { + Zone.getStacktrace = getStacktraceWithCaughtError; + return Zone.getStacktrace(); + } +}; + +Zone.longStackTraceZone = { + getLongStacktrace: function (exception) { + var trace = []; + var zone = this; + if (exception) { + if (zone.stackFramesFilter) { + trace.push(exception.stack.split('\n'). + filter(zone.stackFramesFilter). + join('\n')); + } else { + trace.push(exception.stack); + } } - function observableWindowWithClosingSelector(windowClosingSelector) { - var source = this; - return new AnonymousObservable(function(observer) { - var m = new SerialDisposable(), - d = new CompositeDisposable(m), - r = new RefCountDisposable(d), - win = new Subject(); - observer.onNext(addRef(win, r)); - d.add(source.subscribe(function(x) { - win.onNext(x); - }, function(err) { - win.onError(err); - observer.onError(err); - }, function() { - win.onCompleted(); - observer.onCompleted(); - })); - function createWindowClose() { - var windowClose; - try { - windowClose = windowClosingSelector(); - } catch (e) { - observer.onError(e); - return ; - } - isPromise(windowClose) && (windowClose = observableFromPromise(windowClose)); - var m1 = new SingleAssignmentDisposable(); - m.setDisposable(m1); - m1.setDisposable(windowClose.take(1).subscribe(noop, function(err) { - win.onError(err); - observer.onError(err); - }, function() { - win.onCompleted(); - win = new Subject(); - observer.onNext(addRef(win, r)); - createWindowClose(); - })); - } - createWindowClose(); - return r; - }, source); + var now = Date.now(); + while (zone && zone.constructedAtException) { + trace.push( + '--- ' + (Date(zone.constructedAtTime)).toString() + + ' - ' + (now - zone.constructedAtTime) + 'ms ago', + zone.constructedAtException.get()); + zone = zone.parent; } - observableProto.pairwise = function() { - var source = this; - return new AnonymousObservable(function(observer) { - var previous, - hasPrevious = false; - return source.subscribe(function(x) { - if (hasPrevious) { - observer.onNext([previous, x]); - } else { - hasPrevious = true; - } - previous = x; - }, observer.onError.bind(observer), observer.onCompleted.bind(observer)); - }, source); - }; - observableProto.partition = function(predicate, thisArg) { - return [this.filter(predicate, thisArg), this.filter(function(x, i, o) { - return !predicate.call(thisArg, x, i, o); - })]; + return trace.join('\n'); + }, + + stackFramesFilter: function (line) { + return line.indexOf('zone.js') === -1; + }, + + onError: function (exception) { + var reporter = this.reporter || console.log.bind(console); + reporter(exception.toString()); + reporter(this.getLongStacktrace(exception)); + }, + + '$fork': function (parentFork) { + return function() { + var newZone = parentFork.apply(this, arguments); + newZone.constructedAtException = Zone.getStacktrace(); + newZone.constructedAtTime = Date.now(); + return newZone; + } + } +}; + + +/*! ***************************************************************************** +Copyright (C) Microsoft. All rights reserved. +Licensed under the Apache License, Version 2.0 (the "License"); you may not use +this file except in compliance with the License. You may obtain a copy of the +License at http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + +See the License for the specific language governing permissions and +limitations under the License. +***************************************************************************** */ +"use strict"; +var Reflect; +(function (Reflect) { + // Load global or shim versions of Map, Set, and WeakMap + var functionPrototype = Object.getPrototypeOf(Function); + var _Map = typeof Map === "function" ? Map : CreateMapPolyfill(); + var _Set = typeof Set === "function" ? Set : CreateSetPolyfill(); + var _WeakMap = typeof WeakMap === "function" ? WeakMap : CreateWeakMapPolyfill(); + // [[Metadata]] internal slot + var __Metadata__ = new _WeakMap(); + /** + * Applies a set of decorators to a property of a target object. + * @param decorators An array of decorators. + * @param target The target object. + * @param targetKey (Optional) The property key to decorate. + * @param targetDescriptor (Optional) The property descriptor for the target key + * @remarks Decorators are applied in reverse order. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * C = Reflect.decorate(decoratorsArray, C); + * + * // property (on constructor) + * Reflect.decorate(decoratorsArray, C, "staticProperty"); + * + * // property (on prototype) + * Reflect.decorate(decoratorsArray, C.prototype, "property"); + * + * // method (on constructor) + * Object.defineProperty(C, "staticMethod", + * Reflect.decorate(decoratorsArray, C, "staticMethod", + * Object.getOwnPropertyDescriptor(C, "staticMethod"))); + * + * // method (on prototype) + * Object.defineProperty(C.prototype, "method", + * Reflect.decorate(decoratorsArray, C.prototype, "method", + * Object.getOwnPropertyDescriptor(C.prototype, "method"))); + * + */ + function decorate(decorators, target, targetKey, targetDescriptor) { + if (!IsUndefined(targetDescriptor)) { + if (!IsArray(decorators)) { + throw new TypeError(); + } + else if (!IsObject(target)) { + throw new TypeError(); + } + else if (IsUndefined(targetKey)) { + throw new TypeError(); + } + else if (!IsObject(targetDescriptor)) { + throw new TypeError(); + } + targetKey = ToPropertyKey(targetKey); + return DecoratePropertyWithDescriptor(decorators, target, targetKey, targetDescriptor); + } + else if (!IsUndefined(targetKey)) { + if (!IsArray(decorators)) { + throw new TypeError(); + } + else if (!IsObject(target)) { + throw new TypeError(); + } + targetKey = ToPropertyKey(targetKey); + return DecoratePropertyWithoutDescriptor(decorators, target, targetKey); + } + else { + if (!IsArray(decorators)) { + throw new TypeError(); + } + else if (!IsConstructor(target)) { + throw new TypeError(); + } + return DecorateConstructor(decorators, target); + } + } + Reflect.decorate = decorate; + /** + * A default metadata decorator factory that can be used on a class, class member, or parameter. + * @param metadataKey The key for the metadata entry. + * @param metadataValue The value for the metadata entry. + * @returns A decorator function. + * @remarks + * If `metadataKey` is already defined for the target and target key, the + * metadataValue for that key will be overwritten. + * @example + * + * // constructor + * @Reflect.metadata(key, value) + * class C { + * } + * + * // property (on constructor, TypeScript only) + * class C { + * @Reflect.metadata(key, value) + * static staticProperty; + * } + * + * // property (on prototype, TypeScript only) + * class C { + * @Reflect.metadata(key, value) + * property; + * } + * + * // method (on constructor) + * class C { + * @Reflect.metadata(key, value) + * static staticMethod() { } + * } + * + * // method (on prototype) + * class C { + * @Reflect.metadata(key, value) + * method() { } + * } + * + */ + function metadata(metadataKey, metadataValue) { + function decorator(target, targetKey) { + if (!IsUndefined(targetKey)) { + if (!IsObject(target)) { + throw new TypeError(); + } + targetKey = ToPropertyKey(targetKey); + OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey); + } + else { + if (!IsConstructor(target)) { + throw new TypeError(); + } + OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, undefined); + } + } + return decorator; + } + Reflect.metadata = metadata; + /** + * Define a unique metadata entry on the target. + * @param metadataKey A key used to store and retrieve metadata. + * @param metadataValue A value that contains attached metadata. + * @param target The target object on which to define metadata. + * @param targetKey (Optional) The property key for the target. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * Reflect.defineMetadata("custom:annotation", options, C); + * + * // property (on constructor) + * Reflect.defineMetadata("custom:annotation", options, C, "staticProperty"); + * + * // property (on prototype) + * Reflect.defineMetadata("custom:annotation", options, C.prototype, "property"); + * + * // method (on constructor) + * Reflect.defineMetadata("custom:annotation", options, C, "staticMethod"); + * + * // method (on prototype) + * Reflect.defineMetadata("custom:annotation", options, C.prototype, "method"); + * + * // decorator factory as metadata-producing annotation. + * function MyAnnotation(options): Decorator { + * return (target, key?) => Reflect.defineMetadata("custom:annotation", options, target, key); + * } + * + */ + function defineMetadata(metadataKey, metadataValue, target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + return OrdinaryDefineOwnMetadata(metadataKey, metadataValue, target, targetKey); + } + Reflect.defineMetadata = defineMetadata; + /** + * Gets a value indicating whether the target object or its prototype chain has the provided metadata key defined. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param targetKey (Optional) The property key for the target. + * @returns `true` if the metadata key was defined on the target object or its prototype chain; otherwise, `false`. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.hasMetadata("custom:annotation", C); + * + * // property (on constructor) + * result = Reflect.hasMetadata("custom:annotation", C, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.hasMetadata("custom:annotation", C.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.hasMetadata("custom:annotation", C, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.hasMetadata("custom:annotation", C.prototype, "method"); + * + */ + function hasMetadata(metadataKey, target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + return OrdinaryHasMetadata(metadataKey, target, targetKey); + } + Reflect.hasMetadata = hasMetadata; + /** + * Gets a value indicating whether the target object has the provided metadata key defined. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param targetKey (Optional) The property key for the target. + * @returns `true` if the metadata key was defined on the target object; otherwise, `false`. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.hasOwnMetadata("custom:annotation", C); + * + * // property (on constructor) + * result = Reflect.hasOwnMetadata("custom:annotation", C, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.hasOwnMetadata("custom:annotation", C.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.hasOwnMetadata("custom:annotation", C, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.hasOwnMetadata("custom:annotation", C.prototype, "method"); + * + */ + function hasOwnMetadata(metadataKey, target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + return OrdinaryHasOwnMetadata(metadataKey, target, targetKey); + } + Reflect.hasOwnMetadata = hasOwnMetadata; + /** + * Gets the metadata value for the provided metadata key on the target object or its prototype chain. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param targetKey (Optional) The property key for the target. + * @returns The metadata value for the metadata key if found; otherwise, `undefined`. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getMetadata("custom:annotation", C); + * + * // property (on constructor) + * result = Reflect.getMetadata("custom:annotation", C, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getMetadata("custom:annotation", C.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getMetadata("custom:annotation", C, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getMetadata("custom:annotation", C.prototype, "method"); + * + */ + function getMetadata(metadataKey, target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + return OrdinaryGetMetadata(metadataKey, target, targetKey); + } + Reflect.getMetadata = getMetadata; + /** + * Gets the metadata value for the provided metadata key on the target object. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param targetKey (Optional) The property key for the target. + * @returns The metadata value for the metadata key if found; otherwise, `undefined`. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getOwnMetadata("custom:annotation", C); + * + * // property (on constructor) + * result = Reflect.getOwnMetadata("custom:annotation", C, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getOwnMetadata("custom:annotation", C.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getOwnMetadata("custom:annotation", C, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getOwnMetadata("custom:annotation", C.prototype, "method"); + * + */ + function getOwnMetadata(metadataKey, target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + return OrdinaryGetOwnMetadata(metadataKey, target, targetKey); + } + Reflect.getOwnMetadata = getOwnMetadata; + /** + * Gets the metadata keys defined on the target object or its prototype chain. + * @param target The target object on which the metadata is defined. + * @param targetKey (Optional) The property key for the target. + * @returns An array of unique metadata keys. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getMetadataKeys(C); + * + * // property (on constructor) + * result = Reflect.getMetadataKeys(C, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getMetadataKeys(C.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getMetadataKeys(C, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getMetadataKeys(C.prototype, "method"); + * + */ + function getMetadataKeys(target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + return OrdinaryMetadataKeys(target, targetKey); + } + Reflect.getMetadataKeys = getMetadataKeys; + /** + * Gets the unique metadata keys defined on the target object. + * @param target The target object on which the metadata is defined. + * @param targetKey (Optional) The property key for the target. + * @returns An array of unique metadata keys. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.getOwnMetadataKeys(C); + * + * // property (on constructor) + * result = Reflect.getOwnMetadataKeys(C, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.getOwnMetadataKeys(C.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.getOwnMetadataKeys(C, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.getOwnMetadataKeys(C.prototype, "method"); + * + */ + function getOwnMetadataKeys(target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + return OrdinaryOwnMetadataKeys(target, targetKey); + } + Reflect.getOwnMetadataKeys = getOwnMetadataKeys; + /** + * Deletes the metadata entry from the target object with the provided key. + * @param metadataKey A key used to store and retrieve metadata. + * @param target The target object on which the metadata is defined. + * @param targetKey (Optional) The property key for the target. + * @returns `true` if the metadata entry was found and deleted; otherwise, false. + * @example + * + * class C { + * // property declarations are not part of ES6, though they are valid in TypeScript: + * // static staticProperty; + * // property; + * + * constructor(p) { } + * static staticMethod(p) { } + * method(p) { } + * } + * + * // constructor + * result = Reflect.deleteMetadata("custom:annotation", C); + * + * // property (on constructor) + * result = Reflect.deleteMetadata("custom:annotation", C, "staticProperty"); + * + * // property (on prototype) + * result = Reflect.deleteMetadata("custom:annotation", C.prototype, "property"); + * + * // method (on constructor) + * result = Reflect.deleteMetadata("custom:annotation", C, "staticMethod"); + * + * // method (on prototype) + * result = Reflect.deleteMetadata("custom:annotation", C.prototype, "method"); + * + */ + function deleteMetadata(metadataKey, target, targetKey) { + if (!IsObject(target)) { + throw new TypeError(); + } + else if (!IsUndefined(targetKey)) { + targetKey = ToPropertyKey(targetKey); + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#deletemetadata-metadatakey-p- + var metadataMap = GetOrCreateMetadataMap(target, targetKey, false); + if (IsUndefined(metadataMap)) { + return false; + } + if (!metadataMap.delete(metadataKey)) { + return false; + } + if (metadataMap.size > 0) { + return true; + } + var targetMetadata = __Metadata__.get(target); + targetMetadata.delete(targetKey); + if (targetMetadata.size > 0) { + return true; + } + __Metadata__.delete(target); + return true; + } + Reflect.deleteMetadata = deleteMetadata; + function DecorateConstructor(decorators, target) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i]; + var decorated = decorator(target); + if (!IsUndefined(decorated)) { + if (!IsConstructor(decorated)) { + throw new TypeError(); + } + target = decorated; + } + } + return target; + } + function DecoratePropertyWithDescriptor(decorators, target, propertyKey, descriptor) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i]; + var decorated = decorator(target, propertyKey, descriptor); + if (!IsUndefined(decorated)) { + if (!IsObject(decorated)) { + throw new TypeError(); + } + descriptor = decorated; + } + } + return descriptor; + } + function DecoratePropertyWithoutDescriptor(decorators, target, propertyKey) { + for (var i = decorators.length - 1; i >= 0; --i) { + var decorator = decorators[i]; + decorator(target, propertyKey); + } + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#getorcreatemetadatamap--o-p-create- + function GetOrCreateMetadataMap(target, targetKey, create) { + var targetMetadata = __Metadata__.get(target); + if (!targetMetadata) { + if (!create) { + return undefined; + } + targetMetadata = new _Map(); + __Metadata__.set(target, targetMetadata); + } + var keyMetadata = targetMetadata.get(targetKey); + if (!keyMetadata) { + if (!create) { + return undefined; + } + keyMetadata = new _Map(); + targetMetadata.set(targetKey, keyMetadata); + } + return keyMetadata; + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasmetadata--metadatakey-o-p- + function OrdinaryHasMetadata(MetadataKey, O, P) { + var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) { + return true; + } + var parent = GetPrototypeOf(O); + if (parent !== null) { + return OrdinaryHasMetadata(MetadataKey, parent, P); + } + return false; + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryhasownmetadata--metadatakey-o-p- + function OrdinaryHasOwnMetadata(MetadataKey, O, P) { + var metadataMap = GetOrCreateMetadataMap(O, P, false); + if (metadataMap === undefined) { + return false; + } + return Boolean(metadataMap.has(MetadataKey)); + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetmetadata--metadatakey-o-p- + function OrdinaryGetMetadata(MetadataKey, O, P) { + var hasOwn = OrdinaryHasOwnMetadata(MetadataKey, O, P); + if (hasOwn) { + return OrdinaryGetOwnMetadata(MetadataKey, O, P); + } + var parent = GetPrototypeOf(O); + if (parent !== null) { + return OrdinaryGetMetadata(MetadataKey, parent, P); + } + return undefined; + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarygetownmetadata--metadatakey-o-p- + function OrdinaryGetOwnMetadata(MetadataKey, O, P) { + var metadataMap = GetOrCreateMetadataMap(O, P, false); + if (metadataMap === undefined) { + return undefined; + } + return metadataMap.get(MetadataKey); + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarydefineownmetadata--metadatakey-metadatavalue-o-p- + function OrdinaryDefineOwnMetadata(MetadataKey, MetadataValue, O, P) { + var metadataMap = GetOrCreateMetadataMap(O, P, true); + metadataMap.set(MetadataKey, MetadataValue); + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinarymetadatakeys--o-p- + function OrdinaryMetadataKeys(O, P) { + var ownKeys = OrdinaryOwnMetadataKeys(O, P); + var parent = GetPrototypeOf(O); + if (parent === null) { + return ownKeys; + } + var parentKeys = OrdinaryMetadataKeys(parent, P); + if (parentKeys.length <= 0) { + return ownKeys; + } + if (ownKeys.length <= 0) { + return parentKeys; + } + var set = new _Set(); + var keys = []; + for (var _i = 0; _i < ownKeys.length; _i++) { + var key = ownKeys[_i]; + var hasKey = set.has(key); + if (!hasKey) { + set.add(key); + keys.push(key); + } + } + for (var _a = 0; _a < parentKeys.length; _a++) { + var key = parentKeys[_a]; + var hasKey = set.has(key); + if (!hasKey) { + set.add(key); + keys.push(key); + } + } + return keys; + } + // https://github.com/jonathandturner/decorators/blob/master/specs/metadata.md#ordinaryownmetadatakeys--o-p- + function OrdinaryOwnMetadataKeys(target, targetKey) { + var metadataMap = GetOrCreateMetadataMap(target, targetKey, false); + var keys = []; + if (metadataMap) { + metadataMap.forEach(function (_, key) { return keys.push(key); }); + } + return keys; + } + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-undefined-type + function IsUndefined(x) { + return x === undefined; + } + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isarray + function IsArray(x) { + return Array.isArray(x); + } + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-object-type + function IsObject(x) { + return typeof x === "object" ? x !== null : typeof x === "function"; + } + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-isconstructor + function IsConstructor(x) { + return typeof x === "function"; + } + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-ecmascript-language-types-symbol-type + function IsSymbol(x) { + return typeof x === "symbol"; + } + // https://people.mozilla.org/~jorendorff/es6-draft.html#sec-topropertykey + function ToPropertyKey(value) { + if (IsSymbol(value)) { + return value; + } + return String(value); + } + function GetPrototypeOf(O) { + var proto = Object.getPrototypeOf(O); + if (typeof O !== "function" || O === functionPrototype) { + return proto; + } + // TypeScript doesn't set __proto__ in ES5, as it's non-standard. + // Try to determine the superclass constructor. Compatible implementations + // must either set __proto__ on a subclass constructor to the superclass constructor, + // or ensure each class has a valid `constructor` property on its prototype that + // points back to the constructor. + // If this is not the same as Function.[[Prototype]], then this is definately inherited. + // This is the case when in ES6 or when using __proto__ in a compatible browser. + if (proto !== functionPrototype) { + return proto; + } + // If the super prototype is Object.prototype, null, or undefined, then we cannot determine the heritage. + var prototype = O.prototype; + var prototypeProto = Object.getPrototypeOf(prototype); + if (prototypeProto == null || prototypeProto === Object.prototype) { + return proto; + } + // if the constructor was not a function, then we cannot determine the heritage. + var constructor = prototypeProto.constructor; + if (typeof constructor !== "function") { + return proto; + } + // if we have some kind of self-reference, then we cannot determine the heritage. + if (constructor === O) { + return proto; + } + // we have a pretty good guess at the heritage. + return constructor; + } + // naive Map shim + function CreateMapPolyfill() { + var cacheSentinel = {}; + function Map() { + this._keys = []; + this._values = []; + this._cache = cacheSentinel; + } + Map.prototype = { + get size() { + return this._keys.length; + }, + has: function (key) { + if (key === this._cache) { + return true; + } + if (this._find(key) >= 0) { + this._cache = key; + return true; + } + return false; + }, + get: function (key) { + var index = this._find(key); + if (index >= 0) { + this._cache = key; + return this._values[index]; + } + return undefined; + }, + set: function (key, value) { + this.delete(key); + this._keys.push(key); + this._values.push(value); + this._cache = key; + return this; + }, + delete: function (key) { + var index = this._find(key); + if (index >= 0) { + this._keys.splice(index, 1); + this._values.splice(index, 1); + this._cache = cacheSentinel; + return true; + } + return false; + }, + clear: function () { + this._keys.length = 0; + this._values.length = 0; + this._cache = cacheSentinel; + }, + forEach: function (callback, thisArg) { + var size = this.size; + for (var i = 0; i < size; ++i) { + var key = this._keys[i]; + var value = this._values[i]; + this._cache = key; + callback.call(this, value, key, this); + } + }, + _find: function (key) { + var keys = this._keys; + var size = keys.length; + for (var i = 0; i < size; ++i) { + if (keys[i] === key) { + return i; + } + } + return -1; + } + }; + return Map; + } + // naive Set shim + function CreateSetPolyfill() { + var cacheSentinel = {}; + function Set() { + this._map = new _Map(); + } + Set.prototype = { + get size() { + return this._map.length; + }, + has: function (value) { + return this._map.has(value); + }, + add: function (value) { + this._map.set(value, value); + return this; + }, + delete: function (value) { + return this._map.delete(value); + }, + clear: function () { + this._map.clear(); + }, + forEach: function (callback, thisArg) { + this._map.forEach(callback, thisArg); + } + }; + return Set; + } + // naive WeakMap shim + function CreateWeakMapPolyfill() { + var UUID_SIZE = 16; + var isNode = typeof global !== "undefined" && + typeof module === "object" && + typeof module.exports === "object" && + typeof require === "function"; + var nodeCrypto = isNode && require("crypto"); + var hasOwn = Object.prototype.hasOwnProperty; + var keys = {}; + var rootKey = CreateUniqueKey(); + function WeakMap() { + this._key = CreateUniqueKey(); + } + WeakMap.prototype = { + has: function (target) { + var table = GetOrCreateWeakMapTable(target, false); + if (table) { + return this._key in table; + } + return false; + }, + get: function (target) { + var table = GetOrCreateWeakMapTable(target, false); + if (table) { + return table[this._key]; + } + return undefined; + }, + set: function (target, value) { + var table = GetOrCreateWeakMapTable(target, true); + table[this._key] = value; + return this; + }, + delete: function (target) { + var table = GetOrCreateWeakMapTable(target, false); + if (table && this._key in table) { + return delete table[this._key]; + } + return false; + }, + clear: function () { + // NOTE: not a real clear, just makes the previous data unreachable + this._key = CreateUniqueKey(); + } + }; + function FillRandomBytes(buffer, size) { + for (var i = 0; i < size; ++i) { + buffer[i] = Math.random() * 255 | 0; + } + } + function GenRandomBytes(size) { + if (nodeCrypto) { + var data = nodeCrypto.randomBytes(size); + return data; + } + else if (typeof Uint8Array === "function") { + var data = new Uint8Array(size); + if (typeof crypto !== "undefined") { + crypto.getRandomValues(data); + } + else if (typeof msCrypto !== "undefined") { + msCrypto.getRandomValues(data); + } + else { + FillRandomBytes(data, size); + } + return data; + } + else { + var data = new Array(size); + FillRandomBytes(data, size); + return data; + } + } + function CreateUUID() { + var data = GenRandomBytes(UUID_SIZE); + // mark as random - RFC 4122 § 4.4 + data[6] = data[6] & 0x4f | 0x40; + data[8] = data[8] & 0xbf | 0x80; + var result = ""; + for (var offset = 0; offset < UUID_SIZE; ++offset) { + var byte = data[offset]; + if (offset === 4 || offset === 6 || offset === 8) { + result += "-"; + } + if (byte < 16) { + result += "0"; + } + result += byte.toString(16).toLowerCase(); + } + return result; + } + function CreateUniqueKey() { + var key; + do { + key = "@@WeakMap@@" + CreateUUID(); + } while (hasOwn.call(keys, key)); + keys[key] = true; + return key; + } + function GetOrCreateWeakMapTable(target, create) { + if (!hasOwn.call(target, rootKey)) { + if (!create) { + return undefined; + } + Object.defineProperty(target, rootKey, { value: Object.create(null) }); + } + return target[rootKey]; + } + return WeakMap; + } + // hook global Reflect + (function (__global) { + if (typeof __global.Reflect !== "undefined") { + if (__global.Reflect !== Reflect) { + for (var p in Reflect) { + __global.Reflect[p] = Reflect[p]; + } + } + } + else { + __global.Reflect = Reflect; + } + })(typeof window !== "undefined" ? window : + typeof WorkerGlobalScope !== "undefined" ? self : + typeof global !== "undefined" ? global : + Function("return this;")()); +})(Reflect || (Reflect = {})); +//# sourceMappingURLDisabled=Reflect.js.map +"format register"; +System.register("rx", [], true, function(require, exports, module) { + var global = System.global, + __define = global.define; + global.define = undefined; + ; + (function(undefined) { + var objectTypes = { + 'boolean': false, + 'function': true, + 'object': true, + 'number': false, + 'string': false, + 'undefined': false }; - function enumerableWhile(condition, source) { - return new Enumerable(function() { - return new Enumerator(function() { - return condition() ? { - done: false, - value: source - } : { - done: true, - value: undefined - }; - }); - }); + var root = (objectTypes[typeof window] && window) || this, + freeExports = objectTypes[typeof exports] && exports && !exports.nodeType && exports, + freeModule = objectTypes[typeof module] && module && !module.nodeType && module, + moduleExports = freeModule && freeModule.exports === freeExports && freeExports, + freeGlobal = objectTypes[typeof global] && global; + if (freeGlobal && (freeGlobal.global === freeGlobal || freeGlobal.window === freeGlobal)) { + root = freeGlobal; } - observableProto.letBind = observableProto['let'] = function(func) { - return func(this); - }; - Observable['if'] = Observable.ifThen = function(condition, thenSource, elseSourceOrScheduler) { - return observableDefer(function() { - elseSourceOrScheduler || (elseSourceOrScheduler = observableEmpty()); - isPromise(thenSource) && (thenSource = observableFromPromise(thenSource)); - isPromise(elseSourceOrScheduler) && (elseSourceOrScheduler = observableFromPromise(elseSourceOrScheduler)); - typeof elseSourceOrScheduler.now === 'function' && (elseSourceOrScheduler = observableEmpty(elseSourceOrScheduler)); - return condition() ? thenSource : elseSourceOrScheduler; - }); - }; - Observable['for'] = Observable.forIn = function(sources, resultSelector, thisArg) { - return enumerableOf(sources, resultSelector, thisArg).concat(); - }; - var observableWhileDo = Observable['while'] = Observable.whileDo = function(condition, source) { - isPromise(source) && (source = observableFromPromise(source)); - return enumerableWhile(condition, source).concat(); - }; - observableProto.doWhile = function(condition) { - return observableConcat([this, observableWhileDo(condition, this)]); - }; - Observable['case'] = Observable.switchCase = function(selector, sources, defaultSourceOrScheduler) { - return observableDefer(function() { - isPromise(defaultSourceOrScheduler) && (defaultSourceOrScheduler = observableFromPromise(defaultSourceOrScheduler)); - defaultSourceOrScheduler || (defaultSourceOrScheduler = observableEmpty()); - typeof defaultSourceOrScheduler.now === 'function' && (defaultSourceOrScheduler = observableEmpty(defaultSourceOrScheduler)); - var result = sources[selector()]; - isPromise(result) && (result = observableFromPromise(result)); - return result || defaultSourceOrScheduler; - }); - }; - observableProto.expand = function(selector, scheduler) { - isScheduler(scheduler) || (scheduler = immediateScheduler); - var source = this; - return new AnonymousObservable(function(observer) { - var q = [], - m = new SerialDisposable(), - d = new CompositeDisposable(m), - activeCount = 0, - isAcquired = false; - var ensureActive = function() { - var isOwner = false; - if (q.length > 0) { - isOwner = !isAcquired; - isAcquired = true; - } - if (isOwner) { - m.setDisposable(scheduler.scheduleRecursive(function(self) { - var work; - if (q.length > 0) { - work = q.shift(); - } else { - isAcquired = false; - return ; - } - var m1 = new SingleAssignmentDisposable(); - d.add(m1); - m1.setDisposable(work.subscribe(function(x) { - observer.onNext(x); - var result = null; - try { - result = selector(x); - } catch (e) { - observer.onError(e); - } - q.push(result); - activeCount++; - ensureActive(); - }, observer.onError.bind(observer), function() { - d.remove(m1); - activeCount--; - if (activeCount === 0) { - observer.onCompleted(); - } - })); - self(); - })); - } - }; - q.push(source); - activeCount++; - ensureActive(); - return d; - }, this); - }; - Observable.forkJoin = function() { - var allSources = []; - if (Array.isArray(arguments[0])) { - allSources = arguments[0]; - } else { - for (var i = 0, - len = arguments.length; i < len; i++) { - allSources.push(arguments[i]); - } - } - return new AnonymousObservable(function(subscriber) { - var count = allSources.length; - if (count === 0) { - subscriber.onCompleted(); - return disposableEmpty; - } - var group = new CompositeDisposable(), - finished = false, - hasResults = new Array(count), - hasCompleted = new Array(count), - results = new Array(count); - for (var idx = 0; idx < count; idx++) { - (function(i) { - var source = allSources[i]; - isPromise(source) && (source = observableFromPromise(source)); - group.add(source.subscribe(function(value) { - if (!finished) { - hasResults[i] = true; - results[i] = value; - } - }, function(e) { - finished = true; - subscriber.onError(e); - group.dispose(); - }, function() { - if (!finished) { - if (!hasResults[i]) { - subscriber.onCompleted(); - return ; - } - hasCompleted[i] = true; - for (var ix = 0; ix < count; ix++) { - if (!hasCompleted[ix]) { - return ; - } - } - finished = true; - subscriber.onNext(results); - subscriber.onCompleted(); - } - })); - })(idx); - } - return group; - }); - }; - observableProto.forkJoin = function(second, resultSelector) { - var first = this; - return new AnonymousObservable(function(observer) { - var leftStopped = false, - rightStopped = false, - hasLeft = false, - hasRight = false, - lastLeft, - lastRight, - leftSubscription = new SingleAssignmentDisposable(), - rightSubscription = new SingleAssignmentDisposable(); - isPromise(second) && (second = observableFromPromise(second)); - leftSubscription.setDisposable(first.subscribe(function(left) { - hasLeft = true; - lastLeft = left; - }, function(err) { - rightSubscription.dispose(); - observer.onError(err); - }, function() { - leftStopped = true; - if (rightStopped) { - if (!hasLeft) { - observer.onCompleted(); - } else if (!hasRight) { - observer.onCompleted(); - } else { - var result; - try { - result = resultSelector(lastLeft, lastRight); - } catch (e) { - observer.onError(e); - return ; - } - observer.onNext(result); - observer.onCompleted(); - } - } - })); - rightSubscription.setDisposable(second.subscribe(function(right) { - hasRight = true; - lastRight = right; - }, function(err) { - leftSubscription.dispose(); - observer.onError(err); - }, function() { - rightStopped = true; - if (leftStopped) { - if (!hasLeft) { - observer.onCompleted(); - } else if (!hasRight) { - observer.onCompleted(); - } else { - var result; - try { - result = resultSelector(lastLeft, lastRight); - } catch (e) { - observer.onError(e); - return ; - } - observer.onNext(result); - observer.onCompleted(); - } - } - })); - return new CompositeDisposable(leftSubscription, rightSubscription); - }, first); - }; - observableProto.manySelect = function(selector, scheduler) { - isScheduler(scheduler) || (scheduler = immediateScheduler); - var source = this; - return observableDefer(function() { - var chain; - return source.map(function(x) { - var curr = new ChainObservable(x); - chain && chain.onNext(x); - chain = curr; - return curr; - }).tap(noop, function(e) { - chain && chain.onError(e); - }, function() { - chain && chain.onCompleted(); - }).observeOn(scheduler).map(selector); - }, source); + var Rx = { + internals: {}, + config: {Promise: root.Promise}, + helpers: {} }; - var ChainObservable = (function(__super__) { - function subscribe(observer) { - var self = this, - g = new CompositeDisposable(); - g.add(currentThreadScheduler.schedule(function() { - observer.onNext(self.head); - g.add(self.tail.mergeAll().subscribe(observer)); - })); - return g; - } - inherits(ChainObservable, __super__); - function ChainObservable(head) { - __super__.call(this, subscribe); - this.head = head; - this.tail = new AsyncSubject(); - } - addProperties(ChainObservable.prototype, Observer, { - onCompleted: function() { - this.onNext(Observable.empty()); + var noop = Rx.helpers.noop = function() {}, + notDefined = Rx.helpers.notDefined = function(x) { + return typeof x === 'undefined'; }, - onError: function(e) { - this.onNext(Observable.throwError(e)); + isScheduler = Rx.helpers.isScheduler = function(x) { + return x instanceof Rx.Scheduler; }, - onNext: function(v) { - this.tail.onNext(v); - this.tail.onCompleted(); - } - }); - return ChainObservable; - }(Observable)); - var Map = root.Map || (function() { - function Map() { - this._keys = []; - this._values = []; - } - Map.prototype.get = function(key) { - var i = this._keys.indexOf(key); - return i !== -1 ? this._values[i] : undefined; - }; - Map.prototype.set = function(key, value) { - var i = this._keys.indexOf(key); - i !== -1 && (this._values[i] = value); - this._values[this._keys.push(key) - 1] = value; - }; - Map.prototype.forEach = function(callback, thisArg) { - for (var i = 0, - len = this._keys.length; i < len; i++) { - callback.call(thisArg, this._values[i], this._keys[i]); - } - }; - return Map; - }()); - function Pattern(patterns) { - this.patterns = patterns; - } - Pattern.prototype.and = function(other) { - return new Pattern(this.patterns.concat(other)); - }; - Pattern.prototype.thenDo = function(selector) { - return new Plan(this, selector); - }; - function Plan(expression, selector) { - this.expression = expression; - this.selector = selector; - } - Plan.prototype.activate = function(externalSubscriptions, observer, deactivate) { - var self = this; - var joinObservers = []; - for (var i = 0, - len = this.expression.patterns.length; i < len; i++) { - joinObservers.push(planCreateObserver(externalSubscriptions, this.expression.patterns[i], observer.onError.bind(observer))); - } - var activePlan = new ActivePlan(joinObservers, function() { - var result; - try { - result = self.selector.apply(self, arguments); - } catch (e) { - observer.onError(e); - return ; - } - observer.onNext(result); - }, function() { - for (var j = 0, - jlen = joinObservers.length; j < jlen; j++) { - joinObservers[j].removeActivePlan(activePlan); - } - deactivate(activePlan); - }); - for (i = 0, len = joinObservers.length; i < len; i++) { - joinObservers[i].addActivePlan(activePlan); - } - return activePlan; - }; - function planCreateObserver(externalSubscriptions, observable, onError) { - var entry = externalSubscriptions.get(observable); - if (!entry) { - var observer = new JoinObserver(observable, onError); - externalSubscriptions.set(observable, observer); - return observer; + identity = Rx.helpers.identity = function(x) { + return x; + }, + pluck = Rx.helpers.pluck = function(property) { + return function(x) { + return x[property]; + }; + }, + just = Rx.helpers.just = function(value) { + return function() { + return value; + }; + }, + defaultNow = Rx.helpers.defaultNow = Date.now, + defaultComparer = Rx.helpers.defaultComparer = function(x, y) { + return isEqual(x, y); + }, + defaultSubComparer = Rx.helpers.defaultSubComparer = function(x, y) { + return x > y ? 1 : (x < y ? -1 : 0); + }, + defaultKeySerializer = Rx.helpers.defaultKeySerializer = function(x) { + return x.toString(); + }, + defaultError = Rx.helpers.defaultError = function(err) { + throw err; + }, + isPromise = Rx.helpers.isPromise = function(p) { + return !!p && typeof p.then === 'function'; + }, + asArray = Rx.helpers.asArray = function() { + return Array.prototype.slice.call(arguments); + }, + not = Rx.helpers.not = function(a) { + return !a; + }, + isFunction = Rx.helpers.isFunction = (function() { + var isFn = function(value) { + return typeof value == 'function' || false; + }; + if (isFn(/x/)) { + isFn = function(value) { + return typeof value == 'function' && toString.call(value) == '[object Function]'; + }; + } + return isFn; + }()); + function cloneArray(arr) { + for (var a = [], + i = 0, + len = arr.length; i < len; i++) { + a.push(arr[i]); } - return entry; + return a; } - function ActivePlan(joinObserverArray, onNext, onCompleted) { - this.joinObserverArray = joinObserverArray; - this.onNext = onNext; - this.onCompleted = onCompleted; - this.joinObservers = new Map(); - for (var i = 0, - len = this.joinObserverArray.length; i < len; i++) { - var joinObserver = this.joinObserverArray[i]; - this.joinObservers.set(joinObserver, joinObserver); - } + Rx.config.longStackSupport = false; + var hasStacks = false; + try { + throw new Error(); + } catch (e) { + hasStacks = !!e.stack; } - ActivePlan.prototype.dequeue = function() { - this.joinObservers.forEach(function(v) { - v.queue.shift(); - }); - }; - ActivePlan.prototype.match = function() { - var i, - len, - hasValues = true; - for (i = 0, len = this.joinObserverArray.length; i < len; i++) { - if (this.joinObserverArray[i].queue.length === 0) { - hasValues = false; - break; - } - } - if (hasValues) { - var firstValues = [], - isCompleted = false; - for (i = 0, len = this.joinObserverArray.length; i < len; i++) { - firstValues.push(this.joinObserverArray[i].queue[0]); - this.joinObserverArray[i].queue[0].kind === 'C' && (isCompleted = true); - } - if (isCompleted) { - this.onCompleted(); - } else { - this.dequeue(); - var values = []; - for (i = 0, len = firstValues.length; i < firstValues.length; i++) { - values.push(firstValues[i].value); - } - this.onNext.apply(this, values); - } - } - }; - var JoinObserver = (function(__super__) { - inherits(JoinObserver, __super__); - function JoinObserver(source, onError) { - __super__.call(this); - this.source = source; - this.onError = onError; - this.queue = []; - this.activePlans = []; - this.subscription = new SingleAssignmentDisposable(); - this.isDisposed = false; - } - var JoinObserverPrototype = JoinObserver.prototype; - JoinObserverPrototype.next = function(notification) { - if (!this.isDisposed) { - if (notification.kind === 'E') { - return this.onError(notification.exception); - } - this.queue.push(notification); - var activePlans = this.activePlans.slice(0); - for (var i = 0, - len = activePlans.length; i < len; i++) { - activePlans[i].match(); - } - } - }; - JoinObserverPrototype.error = noop; - JoinObserverPrototype.completed = noop; - JoinObserverPrototype.addActivePlan = function(activePlan) { - this.activePlans.push(activePlan); - }; - JoinObserverPrototype.subscribe = function() { - this.subscription.setDisposable(this.source.materialize().subscribe(this)); - }; - JoinObserverPrototype.removeActivePlan = function(activePlan) { - this.activePlans.splice(this.activePlans.indexOf(activePlan), 1); - this.activePlans.length === 0 && this.dispose(); - }; - JoinObserverPrototype.dispose = function() { - __super__.prototype.dispose.call(this); - if (!this.isDisposed) { - this.isDisposed = true; - this.subscription.dispose(); - } - }; - return JoinObserver; - }(AbstractObserver)); - observableProto.and = function(right) { - return new Pattern([this, right]); - }; - observableProto.thenDo = function(selector) { - return new Pattern([this]).thenDo(selector); - }; - Observable.when = function() { - var len = arguments.length, - plans; - if (Array.isArray(arguments[0])) { - plans = arguments[0]; - } else { - plans = new Array(len); - for (var i = 0; i < len; i++) { - plans[i] = arguments[i]; + var rStartingLine = captureLine(), + rFileName; + var STACK_JUMP_SEPARATOR = "From previous event:"; + function makeStackTraceLong(error, observable) { + if (hasStacks && observable.stack && typeof error === "object" && error !== null && error.stack && error.stack.indexOf(STACK_JUMP_SEPARATOR) === -1) { + var stacks = []; + for (var o = observable; !!o; o = o.source) { + if (o.stack) { + stacks.unshift(o.stack); + } } + stacks.unshift(error.stack); + var concatedStacks = stacks.join("\n" + STACK_JUMP_SEPARATOR + "\n"); + error.stack = filterStackString(concatedStacks); } - return new AnonymousObservable(function(o) { - var activePlans = [], - externalSubscriptions = new Map(); - var outObserver = observerCreate(function(x) { - o.onNext(x); - }, function(err) { - externalSubscriptions.forEach(function(v) { - v.onError(err); - }); - o.onError(err); - }, function(x) { - o.onCompleted(); - }); - try { - for (var i = 0, - len = plans.length; i < len; i++) { - activePlans.push(plans[i].activate(externalSubscriptions, outObserver, function(activePlan) { - var idx = activePlans.indexOf(activePlan); - activePlans.splice(idx, 1); - activePlans.length === 0 && o.onCompleted(); - })); - } - } catch (e) { - observableThrow(e).subscribe(o); + } + function filterStackString(stackString) { + var lines = stackString.split("\n"), + desiredLines = []; + for (var i = 0, + len = lines.length; i < len; i++) { + var line = lines[i]; + if (!isInternalFrame(line) && !isNodeFrame(line) && line) { + desiredLines.push(line); } - var group = new CompositeDisposable(); - externalSubscriptions.forEach(function(joinObserver) { - joinObserver.subscribe(); - group.add(joinObserver); - }); - return group; - }); - }; - function observableTimerDate(dueTime, scheduler) { - return new AnonymousObservable(function(observer) { - return scheduler.scheduleWithAbsolute(dueTime, function() { - observer.onNext(0); - observer.onCompleted(); - }); - }); + } + return desiredLines.join("\n"); } - function observableTimerDateAndPeriod(dueTime, period, scheduler) { - return new AnonymousObservable(function(observer) { - var d = dueTime, - p = normalizeTime(period); - return scheduler.scheduleRecursiveWithAbsoluteAndState(0, d, function(count, self) { - if (p > 0) { - var now = scheduler.now(); - d = d + p; - d <= now && (d = now + p); - } - observer.onNext(count); - self(count + 1, d); - }); - }); + function isInternalFrame(stackLine) { + var fileNameAndLineNumber = getFileNameAndLineNumber(stackLine); + if (!fileNameAndLineNumber) { + return false; + } + var fileName = fileNameAndLineNumber[0], + lineNumber = fileNameAndLineNumber[1]; + return fileName === rFileName && lineNumber >= rStartingLine && lineNumber <= rEndingLine; } - function observableTimerTimeSpan(dueTime, scheduler) { - return new AnonymousObservable(function(observer) { - return scheduler.scheduleWithRelative(normalizeTime(dueTime), function() { - observer.onNext(0); - observer.onCompleted(); - }); - }); + function isNodeFrame(stackLine) { + return stackLine.indexOf("(module.js:") !== -1 || stackLine.indexOf("(node.js:") !== -1; } - function observableTimerTimeSpanAndPeriod(dueTime, period, scheduler) { - return dueTime === period ? new AnonymousObservable(function(observer) { - return scheduler.schedulePeriodicWithState(0, period, function(count) { - observer.onNext(count); - return count + 1; - }); - }) : observableDefer(function() { - return observableTimerDateAndPeriod(scheduler.now() + dueTime, period, scheduler); - }); + function captureLine() { + if (!hasStacks) { + return ; + } + try { + throw new Error(); + } catch (e) { + var lines = e.stack.split("\n"); + var firstLine = lines[0].indexOf("@") > 0 ? lines[1] : lines[2]; + var fileNameAndLineNumber = getFileNameAndLineNumber(firstLine); + if (!fileNameAndLineNumber) { + return ; + } + rFileName = fileNameAndLineNumber[0]; + return fileNameAndLineNumber[1]; + } } - var observableinterval = Observable.interval = function(period, scheduler) { - return observableTimerTimeSpanAndPeriod(period, period, isScheduler(scheduler) ? scheduler : timeoutScheduler); - }; - var observableTimer = Observable.timer = function(dueTime, periodOrScheduler, scheduler) { - var period; - isScheduler(scheduler) || (scheduler = timeoutScheduler); - if (periodOrScheduler !== undefined && typeof periodOrScheduler === 'number') { - period = periodOrScheduler; - } else if (isScheduler(periodOrScheduler)) { - scheduler = periodOrScheduler; + function getFileNameAndLineNumber(stackLine) { + var attempt1 = /at .+ \((.+):(\d+):(?:\d+)\)$/.exec(stackLine); + if (attempt1) { + return [attempt1[1], Number(attempt1[2])]; } - if (dueTime instanceof Date && period === undefined) { - return observableTimerDate(dueTime.getTime(), scheduler); + var attempt2 = /at ([^ ]+):(\d+):(?:\d+)$/.exec(stackLine); + if (attempt2) { + return [attempt2[1], Number(attempt2[2])]; } - if (dueTime instanceof Date && period !== undefined) { - period = periodOrScheduler; - return observableTimerDateAndPeriod(dueTime.getTime(), period, scheduler); + var attempt3 = /.*@(.+):(\d+)$/.exec(stackLine); + if (attempt3) { + return [attempt3[1], Number(attempt3[2])]; } - return period === undefined ? observableTimerTimeSpan(dueTime, scheduler) : observableTimerTimeSpanAndPeriod(dueTime, period, scheduler); - }; - function observableDelayTimeSpan(source, dueTime, scheduler) { - return new AnonymousObservable(function(observer) { - var active = false, - cancelable = new SerialDisposable(), - exception = null, - q = [], - running = false, - subscription; - subscription = source.materialize().timestamp(scheduler).subscribe(function(notification) { - var d, - shouldRun; - if (notification.value.kind === 'E') { - q = []; - q.push(notification); - exception = notification.value.exception; - shouldRun = !running; - } else { - q.push({ - value: notification.value, - timestamp: notification.timestamp + dueTime - }); - shouldRun = !active; - active = true; - } - if (shouldRun) { - if (exception !== null) { - observer.onError(exception); - } else { - d = new SingleAssignmentDisposable(); - cancelable.setDisposable(d); - d.setDisposable(scheduler.scheduleRecursiveWithRelative(dueTime, function(self) { - var e, - recurseDueTime, - result, - shouldRecurse; - if (exception !== null) { - return ; - } - running = true; - do { - result = null; - if (q.length > 0 && q[0].timestamp - scheduler.now() <= 0) { - result = q.shift().value; - } - if (result !== null) { - result.accept(observer); - } - } while (result !== null); - shouldRecurse = false; - recurseDueTime = 0; - if (q.length > 0) { - shouldRecurse = true; - recurseDueTime = Math.max(0, q[0].timestamp - scheduler.now()); - } else { - active = false; - } - e = exception; - running = false; - if (e !== null) { - observer.onError(e); - } else if (shouldRecurse) { - self(recurseDueTime); - } - })); - } - } - }); - return new CompositeDisposable(subscription, cancelable); - }, source); - } - function observableDelayDate(source, dueTime, scheduler) { - return observableDefer(function() { - return observableDelayTimeSpan(source, dueTime - scheduler.now(), scheduler); - }); } - observableProto.delay = function(dueTime, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return dueTime instanceof Date ? observableDelayDate(this, dueTime.getTime(), scheduler) : observableDelayTimeSpan(this, dueTime, scheduler); + var EmptyError = Rx.EmptyError = function() { + this.message = 'Sequence contains no elements.'; + Error.call(this); }; - observableProto.debounce = observableProto.throttleWithTimeout = function(dueTime, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - var source = this; - return new AnonymousObservable(function(observer) { - var cancelable = new SerialDisposable(), - hasvalue = false, - value, - id = 0; - var subscription = source.subscribe(function(x) { - hasvalue = true; - value = x; - id++; - var currentId = id, - d = new SingleAssignmentDisposable(); - cancelable.setDisposable(d); - d.setDisposable(scheduler.scheduleWithRelative(dueTime, function() { - hasvalue && id === currentId && observer.onNext(value); - hasvalue = false; - })); - }, function(e) { - cancelable.dispose(); - observer.onError(e); - hasvalue = false; - id++; - }, function() { - cancelable.dispose(); - hasvalue && observer.onNext(value); - observer.onCompleted(); - hasvalue = false; - id++; - }); - return new CompositeDisposable(subscription, cancelable); - }, this); + EmptyError.prototype = Error.prototype; + var ObjectDisposedError = Rx.ObjectDisposedError = function() { + this.message = 'Object has been disposed'; + Error.call(this); }; - observableProto.throttle = function(dueTime, scheduler) { - return this.debounce(dueTime, scheduler); + ObjectDisposedError.prototype = Error.prototype; + var ArgumentOutOfRangeError = Rx.ArgumentOutOfRangeError = function() { + this.message = 'Argument out of range'; + Error.call(this); }; - observableProto.windowWithTime = function(timeSpan, timeShiftOrScheduler, scheduler) { - var source = this, - timeShift; - timeShiftOrScheduler == null && (timeShift = timeSpan); - isScheduler(scheduler) || (scheduler = timeoutScheduler); - if (typeof timeShiftOrScheduler === 'number') { - timeShift = timeShiftOrScheduler; - } else if (isScheduler(timeShiftOrScheduler)) { - timeShift = timeSpan; - scheduler = timeShiftOrScheduler; - } - return new AnonymousObservable(function(observer) { - var groupDisposable, - nextShift = timeShift, - nextSpan = timeSpan, - q = [], - refCountDisposable, - timerD = new SerialDisposable(), - totalTime = 0; - groupDisposable = new CompositeDisposable(timerD), refCountDisposable = new RefCountDisposable(groupDisposable); - function createTimer() { - var m = new SingleAssignmentDisposable(), - isSpan = false, - isShift = false; - timerD.setDisposable(m); - if (nextSpan === nextShift) { - isSpan = true; - isShift = true; - } else if (nextSpan < nextShift) { - isSpan = true; - } else { - isShift = true; - } - var newTotalTime = isSpan ? nextSpan : nextShift, - ts = newTotalTime - totalTime; - totalTime = newTotalTime; - if (isSpan) { - nextSpan += timeShift; - } - if (isShift) { - nextShift += timeShift; - } - m.setDisposable(scheduler.scheduleWithRelative(ts, function() { - if (isShift) { - var s = new Subject(); - q.push(s); - observer.onNext(addRef(s, refCountDisposable)); - } - isSpan && q.shift().onCompleted(); - createTimer(); - })); - } - ; - q.push(new Subject()); - observer.onNext(addRef(q[0], refCountDisposable)); - createTimer(); - groupDisposable.add(source.subscribe(function(x) { - for (var i = 0, - len = q.length; i < len; i++) { - q[i].onNext(x); - } - }, function(e) { - for (var i = 0, - len = q.length; i < len; i++) { - q[i].onError(e); - } - observer.onError(e); - }, function() { - for (var i = 0, - len = q.length; i < len; i++) { - q[i].onCompleted(); - } - observer.onCompleted(); - })); - return refCountDisposable; - }, source); + ArgumentOutOfRangeError.prototype = Error.prototype; + var NotSupportedError = Rx.NotSupportedError = function(message) { + this.message = message || 'This operation is not supported'; + Error.call(this); }; - observableProto.windowWithTimeOrCount = function(timeSpan, count, scheduler) { - var source = this; - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return new AnonymousObservable(function(observer) { - var timerD = new SerialDisposable(), - groupDisposable = new CompositeDisposable(timerD), - refCountDisposable = new RefCountDisposable(groupDisposable), - n = 0, - windowId = 0, - s = new Subject(); - function createTimer(id) { - var m = new SingleAssignmentDisposable(); - timerD.setDisposable(m); - m.setDisposable(scheduler.scheduleWithRelative(timeSpan, function() { - if (id !== windowId) { - return ; - } - n = 0; - var newId = ++windowId; - s.onCompleted(); - s = new Subject(); - observer.onNext(addRef(s, refCountDisposable)); - createTimer(newId); - })); - } - observer.onNext(addRef(s, refCountDisposable)); - createTimer(0); - groupDisposable.add(source.subscribe(function(x) { - var newId = 0, - newWindow = false; - s.onNext(x); - if (++n === count) { - newWindow = true; - n = 0; - newId = ++windowId; - s.onCompleted(); - s = new Subject(); - observer.onNext(addRef(s, refCountDisposable)); - } - newWindow && createTimer(newId); - }, function(e) { - s.onError(e); - observer.onError(e); - }, function() { - s.onCompleted(); - observer.onCompleted(); - })); - return refCountDisposable; - }, source); + NotSupportedError.prototype = Error.prototype; + var NotImplementedError = Rx.NotImplementedError = function(message) { + this.message = message || 'This operation is not implemented'; + Error.call(this); }; - observableProto.bufferWithTime = function(timeSpan, timeShiftOrScheduler, scheduler) { - return this.windowWithTime.apply(this, arguments).selectMany(function(x) { - return x.toArray(); - }); + NotImplementedError.prototype = Error.prototype; + var notImplemented = Rx.helpers.notImplemented = function() { + throw new NotImplementedError(); }; - observableProto.bufferWithTimeOrCount = function(timeSpan, count, scheduler) { - return this.windowWithTimeOrCount(timeSpan, count, scheduler).selectMany(function(x) { - return x.toArray(); - }); + var notSupported = Rx.helpers.notSupported = function() { + throw new NotSupportedError(); }; - observableProto.timeInterval = function(scheduler) { - var source = this; - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return observableDefer(function() { - var last = scheduler.now(); - return source.map(function(x) { - var now = scheduler.now(), - span = now - last; - last = now; - return { - value: x, - interval: span - }; - }); - }); + var $iterator$ = (typeof Symbol === 'function' && Symbol.iterator) || '_es6shim_iterator_'; + if (root.Set && typeof new root.Set()['@@iterator'] === 'function') { + $iterator$ = '@@iterator'; + } + var doneEnumerator = Rx.doneEnumerator = { + done: true, + value: undefined }; - observableProto.timestamp = function(scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return this.map(function(x) { - return { - value: x, - timestamp: scheduler.now() - }; - }); + var isIterable = Rx.helpers.isIterable = function(o) { + return o[$iterator$] !== undefined; }; - function sampleObservable(source, sampler) { - return new AnonymousObservable(function(observer) { - var atEnd, - value, - hasValue; - function sampleSubscribe() { - if (hasValue) { - hasValue = false; - observer.onNext(value); - } - atEnd && observer.onCompleted(); - } - return new CompositeDisposable(source.subscribe(function(newValue) { - hasValue = true; - value = newValue; - }, observer.onError.bind(observer), function() { - atEnd = true; - }), sampler.subscribe(sampleSubscribe, observer.onError.bind(observer), sampleSubscribe)); - }, source); + var isArrayLike = Rx.helpers.isArrayLike = function(o) { + return o && o.length !== undefined; + }; + Rx.helpers.iterator = $iterator$; + var bindCallback = Rx.internals.bindCallback = function(func, thisArg, argCount) { + if (typeof thisArg === 'undefined') { + return func; + } + switch (argCount) { + case 0: + return function() { + return func.call(thisArg); + }; + case 1: + return function(arg) { + return func.call(thisArg, arg); + }; + case 2: + return function(value, index) { + return func.call(thisArg, value, index); + }; + case 3: + return function(value, index, collection) { + return func.call(thisArg, value, index, collection); + }; + } + return function() { + return func.apply(thisArg, arguments); + }; + }; + var dontEnums = ['toString', 'toLocaleString', 'valueOf', 'hasOwnProperty', 'isPrototypeOf', 'propertyIsEnumerable', 'constructor'], + dontEnumsLength = dontEnums.length; + var argsClass = '[object Arguments]', + arrayClass = '[object Array]', + boolClass = '[object Boolean]', + dateClass = '[object Date]', + errorClass = '[object Error]', + funcClass = '[object Function]', + numberClass = '[object Number]', + objectClass = '[object Object]', + regexpClass = '[object RegExp]', + stringClass = '[object String]'; + var toString = Object.prototype.toString, + hasOwnProperty = Object.prototype.hasOwnProperty, + supportsArgsClass = toString.call(arguments) == argsClass, + supportNodeClass, + errorProto = Error.prototype, + objectProto = Object.prototype, + stringProto = String.prototype, + propertyIsEnumerable = objectProto.propertyIsEnumerable; + try { + supportNodeClass = !(toString.call(document) == objectClass && !({'toString': 0} + '')); + } catch (e) { + supportNodeClass = true; } - observableProto.sample = observableProto.throttleLatest = function(intervalOrSampler, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return typeof intervalOrSampler === 'number' ? sampleObservable(this, observableinterval(intervalOrSampler, scheduler)) : sampleObservable(this, intervalOrSampler); - }; - observableProto.timeout = function(dueTime, other, scheduler) { - (other == null || typeof other === 'string') && (other = observableThrow(new Error(other || 'Timeout'))); - isScheduler(scheduler) || (scheduler = timeoutScheduler); - var source = this, - schedulerMethod = dueTime instanceof Date ? 'scheduleWithAbsolute' : 'scheduleWithRelative'; - return new AnonymousObservable(function(observer) { - var id = 0, - original = new SingleAssignmentDisposable(), - subscription = new SerialDisposable(), - switched = false, - timer = new SerialDisposable(); - subscription.setDisposable(original); - function createTimer() { - var myId = id; - timer.setDisposable(scheduler[schedulerMethod](dueTime, function() { - if (id === myId) { - isPromise(other) && (other = observableFromPromise(other)); - subscription.setDisposable(other.subscribe(observer)); - } - })); - } - createTimer(); - original.setDisposable(source.subscribe(function(x) { - if (!switched) { - id++; - observer.onNext(x); - createTimer(); - } - }, function(e) { - if (!switched) { - id++; - observer.onError(e); - } - }, function() { - if (!switched) { - id++; - observer.onCompleted(); - } - })); - return new CompositeDisposable(subscription, timer); - }, source); + var nonEnumProps = {}; + nonEnumProps[arrayClass] = nonEnumProps[dateClass] = nonEnumProps[numberClass] = { + 'constructor': true, + 'toLocaleString': true, + 'toString': true, + 'valueOf': true }; - Observable.generateWithAbsoluteTime = function(initialState, condition, iterate, resultSelector, timeSelector, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return new AnonymousObservable(function(observer) { - var first = true, - hasResult = false, - result, - state = initialState, - time; - return scheduler.scheduleRecursiveWithAbsolute(scheduler.now(), function(self) { - hasResult && observer.onNext(result); - try { - if (first) { - first = false; - } else { - state = iterate(state); - } - hasResult = condition(state); - if (hasResult) { - result = resultSelector(state); - time = timeSelector(state); - } - } catch (e) { - observer.onError(e); - return ; - } - if (hasResult) { - self(time); - } else { - observer.onCompleted(); - } - }); - }); + nonEnumProps[boolClass] = nonEnumProps[stringClass] = { + 'constructor': true, + 'toString': true, + 'valueOf': true }; - Observable.generateWithRelativeTime = function(initialState, condition, iterate, resultSelector, timeSelector, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return new AnonymousObservable(function(observer) { - var first = true, - hasResult = false, - result, - state = initialState, - time; - return scheduler.scheduleRecursiveWithRelative(0, function(self) { - hasResult && observer.onNext(result); - try { - if (first) { - first = false; - } else { - state = iterate(state); - } - hasResult = condition(state); - if (hasResult) { - result = resultSelector(state); - time = timeSelector(state); - } - } catch (e) { - observer.onError(e); - return ; - } - if (hasResult) { - self(time); - } else { - observer.onCompleted(); - } - }); - }); + nonEnumProps[errorClass] = nonEnumProps[funcClass] = nonEnumProps[regexpClass] = { + 'constructor': true, + 'toString': true }; - observableProto.delaySubscription = function(dueTime, scheduler) { - return this.delayWithSelector(observableTimer(dueTime, isScheduler(scheduler) ? scheduler : timeoutScheduler), observableEmpty); + nonEnumProps[objectClass] = {'constructor': true}; + var support = {}; + (function() { + var ctor = function() { + this.x = 1; + }, + props = []; + ctor.prototype = { + 'valueOf': 1, + 'y': 1 + }; + for (var key in new ctor) { + props.push(key); + } + for (key in arguments) {} + support.enumErrorProps = propertyIsEnumerable.call(errorProto, 'message') || propertyIsEnumerable.call(errorProto, 'name'); + support.enumPrototypes = propertyIsEnumerable.call(ctor, 'prototype'); + support.nonEnumArgs = key != 0; + support.nonEnumShadows = !/valueOf/.test(props); + }(1)); + var isObject = Rx.internals.isObject = function(value) { + var type = typeof value; + return value && (type == 'function' || type == 'object') || false; }; - observableProto.delayWithSelector = function(subscriptionDelay, delayDurationSelector) { - var source = this, - subDelay, - selector; - if (typeof subscriptionDelay === 'function') { - selector = subscriptionDelay; - } else { - subDelay = subscriptionDelay; - selector = delayDurationSelector; + function keysIn(object) { + var result = []; + if (!isObject(object)) { + return result; } - return new AnonymousObservable(function(observer) { - var delays = new CompositeDisposable(), - atEnd = false, - done = function() { - if (atEnd && delays.length === 0) { - observer.onCompleted(); - } - }, - subscription = new SerialDisposable(), - start = function() { - subscription.setDisposable(source.subscribe(function(x) { - var delay; - try { - delay = selector(x); - } catch (error) { - observer.onError(error); - return ; - } - var d = new SingleAssignmentDisposable(); - delays.add(d); - d.setDisposable(delay.subscribe(function() { - observer.onNext(x); - delays.remove(d); - done(); - }, observer.onError.bind(observer), function() { - observer.onNext(x); - delays.remove(d); - done(); - })); - }, observer.onError.bind(observer), function() { - atEnd = true; - subscription.dispose(); - done(); - })); - }; - if (!subDelay) { - start(); - } else { - subscription.setDisposable(subDelay.subscribe(start, observer.onError.bind(observer), start)); + if (support.nonEnumArgs && object.length && isArguments(object)) { + object = slice.call(object); + } + var skipProto = support.enumPrototypes && typeof object == 'function', + skipErrorProps = support.enumErrorProps && (object === errorProto || object instanceof Error); + for (var key in object) { + if (!(skipProto && key == 'prototype') && !(skipErrorProps && (key == 'message' || key == 'name'))) { + result.push(key); } - return new CompositeDisposable(subscription, delays); - }, this); - }; - observableProto.timeoutWithSelector = function(firstTimeout, timeoutdurationSelector, other) { - if (arguments.length === 1) { - timeoutdurationSelector = firstTimeout; - firstTimeout = observableNever(); } - other || (other = observableThrow(new Error('Timeout'))); - var source = this; - return new AnonymousObservable(function(observer) { - var subscription = new SerialDisposable(), - timer = new SerialDisposable(), - original = new SingleAssignmentDisposable(); - subscription.setDisposable(original); - var id = 0, - switched = false; - function setTimer(timeout) { - var myId = id; - function timerWins() { - return id === myId; - } - var d = new SingleAssignmentDisposable(); - timer.setDisposable(d); - d.setDisposable(timeout.subscribe(function() { - timerWins() && subscription.setDisposable(other.subscribe(observer)); - d.dispose(); - }, function(e) { - timerWins() && observer.onError(e); - }, function() { - timerWins() && subscription.setDisposable(other.subscribe(observer)); - })); + if (support.nonEnumShadows && object !== objectProto) { + var ctor = object.constructor, + index = -1, + length = dontEnumsLength; + if (object === (ctor && ctor.prototype)) { + var className = object === stringProto ? stringClass : object === errorProto ? errorClass : toString.call(object), + nonEnum = nonEnumProps[className]; } - ; - setTimer(firstTimeout); - function observerWins() { - var res = !switched; - if (res) { - id++; - } - return res; - } - original.setDisposable(source.subscribe(function(x) { - if (observerWins()) { - observer.onNext(x); - var timeout; - try { - timeout = timeoutdurationSelector(x); - } catch (e) { - observer.onError(e); - return ; - } - setTimer(isPromise(timeout) ? observableFromPromise(timeout) : timeout); - } - }, function(e) { - observerWins() && observer.onError(e); - }, function() { - observerWins() && observer.onCompleted(); - })); - return new CompositeDisposable(subscription, timer); - }, source); - }; - observableProto.debounceWithSelector = function(durationSelector) { - var source = this; - return new AnonymousObservable(function(observer) { - var value, - hasValue = false, - cancelable = new SerialDisposable(), - id = 0; - var subscription = source.subscribe(function(x) { - var throttle; - try { - throttle = durationSelector(x); - } catch (e) { - observer.onError(e); - return ; + while (++index < length) { + key = dontEnums[index]; + if (!(nonEnum && nonEnum[key]) && hasOwnProperty.call(object, key)) { + result.push(key); } - isPromise(throttle) && (throttle = observableFromPromise(throttle)); - hasValue = true; - value = x; - id++; - var currentid = id, - d = new SingleAssignmentDisposable(); - cancelable.setDisposable(d); - d.setDisposable(throttle.subscribe(function() { - hasValue && id === currentid && observer.onNext(value); - hasValue = false; - d.dispose(); - }, observer.onError.bind(observer), function() { - hasValue && id === currentid && observer.onNext(value); - hasValue = false; - d.dispose(); - })); - }, function(e) { - cancelable.dispose(); - observer.onError(e); - hasValue = false; - id++; - }, function() { - cancelable.dispose(); - hasValue && observer.onNext(value); - observer.onCompleted(); - hasValue = false; - id++; - }); - return new CompositeDisposable(subscription, cancelable); - }, source); + } + } + return result; + } + function internalFor(object, callback, keysFunc) { + var index = -1, + props = keysFunc(object), + length = props.length; + while (++index < length) { + var key = props[index]; + if (callback(object[key], key, object) === false) { + break; + } + } + return object; + } + function internalForIn(object, callback) { + return internalFor(object, callback, keysIn); + } + function isNode(value) { + return typeof value.toString != 'function' && typeof(value + '') == 'string'; + } + var isArguments = function(value) { + return (value && typeof value == 'object') ? toString.call(value) == argsClass : false; }; - observableProto.throttleWithSelector = function(durationSelector) { - return this.debounceWithSelector(durationSelector); + if (!supportsArgsClass) { + isArguments = function(value) { + return (value && typeof value == 'object') ? hasOwnProperty.call(value, 'callee') : false; + }; + } + var isEqual = Rx.internals.isEqual = function(x, y) { + return deepEquals(x, y, [], []); }; - observableProto.skipLastWithTime = function(duration, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - var source = this; - return new AnonymousObservable(function(o) { - var q = []; - return source.subscribe(function(x) { - var now = scheduler.now(); - q.push({ - interval: now, - value: x - }); - while (q.length > 0 && now - q[0].interval >= duration) { - o.onNext(q.shift().value); + function deepEquals(a, b, stackA, stackB) { + if (a === b) { + return a !== 0 || (1 / a == 1 / b); + } + var type = typeof a, + otherType = typeof b; + if (a === a && (a == null || b == null || (type != 'function' && type != 'object' && otherType != 'function' && otherType != 'object'))) { + return false; + } + var className = toString.call(a), + otherClass = toString.call(b); + if (className == argsClass) { + className = objectClass; + } + if (otherClass == argsClass) { + otherClass = objectClass; + } + if (className != otherClass) { + return false; + } + switch (className) { + case boolClass: + case dateClass: + return +a == +b; + case numberClass: + return (a != +a) ? b != +b : (a == 0 ? (1 / a == 1 / b) : a == +b); + case regexpClass: + case stringClass: + return a == String(b); + } + var isArr = className == arrayClass; + if (!isArr) { + if (className != objectClass || (!support.nodeClass && (isNode(a) || isNode(b)))) { + return false; + } + var ctorA = !support.argsObject && isArguments(a) ? Object : a.constructor, + ctorB = !support.argsObject && isArguments(b) ? Object : b.constructor; + if (ctorA != ctorB && !(hasOwnProperty.call(a, 'constructor') && hasOwnProperty.call(b, 'constructor')) && !(isFunction(ctorA) && ctorA instanceof ctorA && isFunction(ctorB) && ctorB instanceof ctorB) && ('constructor' in a && 'constructor' in b)) { + return false; + } + } + var initedStack = !stackA; + stackA || (stackA = []); + stackB || (stackB = []); + var length = stackA.length; + while (length--) { + if (stackA[length] == a) { + return stackB[length] == b; + } + } + var size = 0; + var result = true; + stackA.push(a); + stackB.push(b); + if (isArr) { + length = a.length; + size = b.length; + result = size == length; + if (result) { + while (size--) { + var index = length, + value = b[size]; + if (!(result = deepEquals(a[size], value, stackA, stackB))) { + break; + } } - }, function(e) { - o.onError(e); - }, function() { - var now = scheduler.now(); - while (q.length > 0 && now - q[0].interval >= duration) { - o.onNext(q.shift().value); + } + } else { + internalForIn(b, function(value, key, b) { + if (hasOwnProperty.call(b, key)) { + size++; + return (result = hasOwnProperty.call(a, key) && deepEquals(a[key], value, stackA, stackB)); } - o.onCompleted(); }); - }, source); - }; - observableProto.takeLastWithTime = function(duration, scheduler) { - var source = this; - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return new AnonymousObservable(function(o) { - var q = []; - return source.subscribe(function(x) { - var now = scheduler.now(); - q.push({ - interval: now, - value: x - }); - while (q.length > 0 && now - q[0].interval >= duration) { - q.shift(); - } - }, function(e) { - o.onError(e); - }, function() { - var now = scheduler.now(); - while (q.length > 0) { - var next = q.shift(); - if (now - next.interval <= duration) { - o.onNext(next.value); + if (result) { + internalForIn(a, function(value, key, a) { + if (hasOwnProperty.call(a, key)) { + return (result = --size > -1); } - } - o.onCompleted(); - }); - }, source); - }; - observableProto.takeLastBufferWithTime = function(duration, scheduler) { - var source = this; - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return new AnonymousObservable(function(o) { - var q = []; - return source.subscribe(function(x) { - var now = scheduler.now(); - q.push({ - interval: now, - value: x }); - while (q.length > 0 && now - q[0].interval >= duration) { - q.shift(); - } - }, function(e) { - o.onError(e); - }, function() { - var now = scheduler.now(), - res = []; - while (q.length > 0) { - var next = q.shift(); - now - next.interval <= duration && res.push(next.value); - } - o.onNext(res); - o.onCompleted(); - }); - }, source); + } + } + stackA.pop(); + stackB.pop(); + return result; + } + var hasProp = {}.hasOwnProperty, + slice = Array.prototype.slice; + var inherits = this.inherits = Rx.internals.inherits = function(child, parent) { + function __() { + this.constructor = child; + } + __.prototype = parent.prototype; + child.prototype = new __(); }; - observableProto.takeWithTime = function(duration, scheduler) { - var source = this; - isScheduler(scheduler) || (scheduler = timeoutScheduler); - return new AnonymousObservable(function(o) { - return new CompositeDisposable(scheduler.scheduleWithRelative(duration, function() { - o.onCompleted(); - }), source.subscribe(o)); - }, source); + var addProperties = Rx.internals.addProperties = function(obj) { + for (var sources = [], + i = 1, + len = arguments.length; i < len; i++) { + sources.push(arguments[i]); + } + for (var idx = 0, + ln = sources.length; idx < ln; idx++) { + var source = sources[idx]; + for (var prop in source) { + obj[prop] = source[prop]; + } + } }; - observableProto.skipWithTime = function(duration, scheduler) { - var source = this; - isScheduler(scheduler) || (scheduler = timeoutScheduler); + var addRef = Rx.internals.addRef = function(xs, r) { return new AnonymousObservable(function(observer) { - var open = false; - return new CompositeDisposable(scheduler.scheduleWithRelative(duration, function() { - open = true; - }), source.subscribe(function(x) { - open && observer.onNext(x); - }, observer.onError.bind(observer), observer.onCompleted.bind(observer))); - }, source); - }; - observableProto.skipUntilWithTime = function(startTime, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - var source = this, - schedulerMethod = startTime instanceof Date ? 'scheduleWithAbsolute' : 'scheduleWithRelative'; - return new AnonymousObservable(function(o) { - var open = false; - return new CompositeDisposable(scheduler[schedulerMethod](startTime, function() { - open = true; - }), source.subscribe(function(x) { - open && o.onNext(x); - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - })); - }, source); - }; - observableProto.takeUntilWithTime = function(endTime, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - var source = this, - schedulerMethod = endTime instanceof Date ? 'scheduleWithAbsolute' : 'scheduleWithRelative'; - return new AnonymousObservable(function(o) { - return new CompositeDisposable(scheduler[schedulerMethod](endTime, function() { - o.onCompleted(); - }), source.subscribe(o)); - }, source); + return new CompositeDisposable(r.getDisposable(), xs.subscribe(observer)); + }); }; - observableProto.throttleFirst = function(windowDuration, scheduler) { - isScheduler(scheduler) || (scheduler = timeoutScheduler); - var duration = +windowDuration || 0; - if (duration <= 0) { - throw new RangeError('windowDuration cannot be less or equal zero.'); + function arrayInitialize(count, factory) { + var a = new Array(count); + for (var i = 0; i < count; i++) { + a[i] = factory(); } - var source = this; - return new AnonymousObservable(function(o) { - var lastOnNext = 0; - return source.subscribe(function(x) { - var now = scheduler.now(); - if (lastOnNext === 0 || now - lastOnNext >= duration) { - lastOnNext = now; - o.onNext(x); - } - }, function(e) { - o.onError(e); - }, function() { - o.onCompleted(); - }); - }, source); - }; - observableProto.transduce = function(transducer) { - var source = this; - function transformForObserver(o) { - return { - '@@transducer/init': function() { - return o; - }, - '@@transducer/step': function(obs, input) { - return obs.onNext(input); - }, - '@@transducer/result': function(obs) { - return obs.onCompleted(); - } - }; + return a; + } + var errorObj = {e: {}}; + var tryCatchTarget; + function tryCatcher() { + try { + return tryCatchTarget.apply(this, arguments); + } catch (e) { + errorObj.e = e; + return errorObj; } - return new AnonymousObservable(function(o) { - var xform = transducer(transformForObserver(o)); - return source.subscribe(function(v) { - try { - xform['@@transducer/step'](o, v); - } catch (e) { - o.onError(e); - } - }, function(e) { - o.onError(e); - }, function() { - xform['@@transducer/result'](o); - }); - }, source); + } + function tryCatch(fn) { + if (!isFunction(fn)) { + throw new TypeError('fn must be a function'); + } + tryCatchTarget = fn; + return tryCatcher; + } + function thrower(e) { + throw e; + } + function IndexedItem(id, value) { + this.id = id; + this.value = value; + } + IndexedItem.prototype.compareTo = function(other) { + var c = this.value.compareTo(other.value); + c === 0 && (c = this.id - other.id); + return c; }; - observableProto.exclusive = function() { - var sources = this; - return new AnonymousObservable(function(observer) { - var hasCurrent = false, - isStopped = false, - m = new SingleAssignmentDisposable(), - g = new CompositeDisposable(); - g.add(m); - m.setDisposable(sources.subscribe(function(innerSource) { - if (!hasCurrent) { - hasCurrent = true; - isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); - var innerSubscription = new SingleAssignmentDisposable(); - g.add(innerSubscription); - innerSubscription.setDisposable(innerSource.subscribe(observer.onNext.bind(observer), observer.onError.bind(observer), function() { - g.remove(innerSubscription); - hasCurrent = false; - if (isStopped && g.length === 1) { - observer.onCompleted(); - } - })); - } - }, observer.onError.bind(observer), function() { - isStopped = true; - if (!hasCurrent && g.length === 1) { - observer.onCompleted(); - } - })); - return g; - }, this); + var PriorityQueue = Rx.internals.PriorityQueue = function(capacity) { + this.items = new Array(capacity); + this.length = 0; }; - observableProto.exclusiveMap = function(selector, thisArg) { - var sources = this, - selectorFunc = bindCallback(selector, thisArg, 3); - return new AnonymousObservable(function(observer) { - var index = 0, - hasCurrent = false, - isStopped = true, - m = new SingleAssignmentDisposable(), - g = new CompositeDisposable(); - g.add(m); - m.setDisposable(sources.subscribe(function(innerSource) { - if (!hasCurrent) { - hasCurrent = true; - innerSubscription = new SingleAssignmentDisposable(); - g.add(innerSubscription); - isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); - innerSubscription.setDisposable(innerSource.subscribe(function(x) { - var result; - try { - result = selectorFunc(x, index++, innerSource); - } catch (e) { - observer.onError(e); - return ; - } - observer.onNext(result); - }, function(e) { - observer.onError(e); - }, function() { - g.remove(innerSubscription); - hasCurrent = false; - if (isStopped && g.length === 1) { - observer.onCompleted(); - } - })); - } - }, function(e) { - observer.onError(e); - }, function() { - isStopped = true; - if (g.length === 1 && !hasCurrent) { - observer.onCompleted(); - } - })); - return g; - }, this); + var priorityProto = PriorityQueue.prototype; + priorityProto.isHigherPriority = function(left, right) { + return this.items[left].compareTo(this.items[right]) < 0; }; - Rx.VirtualTimeScheduler = (function(__super__) { - function localNow() { - return this.toDateTimeOffset(this.clock); + priorityProto.percolate = function(index) { + if (index >= this.length || index < 0) { + return ; } - function scheduleNow(state, action) { - return this.scheduleAbsoluteWithState(state, this.clock, action); + var parent = index - 1 >> 1; + if (parent < 0 || parent === index) { + return ; + } + if (this.isHigherPriority(index, parent)) { + var temp = this.items[index]; + this.items[index] = this.items[parent]; + this.items[parent] = temp; + this.percolate(parent); + } + }; + priorityProto.heapify = function(index) { + +index || (index = 0); + if (index >= this.length || index < 0) { + return ; + } + var left = 2 * index + 1, + right = 2 * index + 2, + first = index; + if (left < this.length && this.isHigherPriority(left, first)) { + first = left; } - function scheduleRelative(state, dueTime, action) { - return this.scheduleRelativeWithState(state, this.toRelative(dueTime), action); + if (right < this.length && this.isHigherPriority(right, first)) { + first = right; } - function scheduleAbsolute(state, dueTime, action) { - return this.scheduleRelativeWithState(state, this.toRelative(dueTime - this.now()), action); + if (first !== index) { + var temp = this.items[index]; + this.items[index] = this.items[first]; + this.items[first] = temp; + this.heapify(first); } - function invokeAction(scheduler, action) { - action(); - return disposableEmpty; + }; + priorityProto.peek = function() { + return this.items[0].value; + }; + priorityProto.removeAt = function(index) { + this.items[index] = this.items[--this.length]; + this.items[this.length] = undefined; + this.heapify(); + }; + priorityProto.dequeue = function() { + var result = this.peek(); + this.removeAt(0); + return result; + }; + priorityProto.enqueue = function(item) { + var index = this.length++; + this.items[index] = new IndexedItem(PriorityQueue.count++, item); + this.percolate(index); + }; + priorityProto.remove = function(item) { + for (var i = 0; i < this.length; i++) { + if (this.items[i].value === item) { + this.removeAt(i); + return true; + } } - inherits(VirtualTimeScheduler, __super__); - function VirtualTimeScheduler(initialClock, comparer) { - this.clock = initialClock; - this.comparer = comparer; - this.isEnabled = false; - this.queue = new PriorityQueue(1024); - __super__.call(this, localNow, scheduleNow, scheduleRelative, scheduleAbsolute); + return false; + }; + PriorityQueue.count = 0; + var CompositeDisposable = Rx.CompositeDisposable = function() { + var args = [], + i, + len; + if (Array.isArray(arguments[0])) { + args = arguments[0]; + len = args.length; + } else { + len = arguments.length; + args = new Array(len); + for (i = 0; i < len; i++) { + args[i] = arguments[i]; + } } - var VirtualTimeSchedulerPrototype = VirtualTimeScheduler.prototype; - VirtualTimeSchedulerPrototype.add = notImplemented; - VirtualTimeSchedulerPrototype.toDateTimeOffset = notImplemented; - VirtualTimeSchedulerPrototype.toRelative = notImplemented; - VirtualTimeSchedulerPrototype.schedulePeriodicWithState = function(state, period, action) { - var s = new SchedulePeriodicRecursive(this, state, period, action); - return s.start(); - }; - VirtualTimeSchedulerPrototype.scheduleRelativeWithState = function(state, dueTime, action) { - var runAt = this.add(this.clock, dueTime); - return this.scheduleAbsoluteWithState(state, runAt, action); - }; - VirtualTimeSchedulerPrototype.scheduleRelative = function(dueTime, action) { - return this.scheduleRelativeWithState(action, dueTime, invokeAction); - }; - VirtualTimeSchedulerPrototype.start = function() { - if (!this.isEnabled) { - this.isEnabled = true; - do { - var next = this.getNext(); - if (next !== null) { - this.comparer(next.dueTime, this.clock) > 0 && (this.clock = next.dueTime); - next.invoke(); - } else { - this.isEnabled = false; - } - } while (this.isEnabled); + for (i = 0; i < len; i++) { + if (!isDisposable(args[i])) { + throw new TypeError('Not a disposable'); } - }; - VirtualTimeSchedulerPrototype.stop = function() { - this.isEnabled = false; - }; - VirtualTimeSchedulerPrototype.advanceTo = function(time) { - var dueToClock = this.comparer(this.clock, time); - if (this.comparer(this.clock, time) > 0) { - throw new ArgumentOutOfRangeError(); + } + this.disposables = args; + this.isDisposed = false; + this.length = args.length; + }; + var CompositeDisposablePrototype = CompositeDisposable.prototype; + CompositeDisposablePrototype.add = function(item) { + if (this.isDisposed) { + item.dispose(); + } else { + this.disposables.push(item); + this.length++; + } + }; + CompositeDisposablePrototype.remove = function(item) { + var shouldDispose = false; + if (!this.isDisposed) { + var idx = this.disposables.indexOf(item); + if (idx !== -1) { + shouldDispose = true; + this.disposables.splice(idx, 1); + this.length--; + item.dispose(); } - if (dueToClock === 0) { - return ; + } + return shouldDispose; + }; + CompositeDisposablePrototype.dispose = function() { + if (!this.isDisposed) { + this.isDisposed = true; + var len = this.disposables.length, + currentDisposables = new Array(len); + for (var i = 0; i < len; i++) { + currentDisposables[i] = this.disposables[i]; } - if (!this.isEnabled) { - this.isEnabled = true; - do { - var next = this.getNext(); - if (next !== null && this.comparer(next.dueTime, time) <= 0) { - this.comparer(next.dueTime, this.clock) > 0 && (this.clock = next.dueTime); - next.invoke(); - } else { - this.isEnabled = false; - } - } while (this.isEnabled); - this.clock = time; + this.disposables = []; + this.length = 0; + for (i = 0; i < len; i++) { + currentDisposables[i].dispose(); } + } + }; + var Disposable = Rx.Disposable = function(action) { + this.isDisposed = false; + this.action = action || noop; + }; + Disposable.prototype.dispose = function() { + if (!this.isDisposed) { + this.action(); + this.isDisposed = true; + } + }; + var disposableCreate = Disposable.create = function(action) { + return new Disposable(action); + }; + var disposableEmpty = Disposable.empty = {dispose: noop}; + var isDisposable = Disposable.isDisposable = function(d) { + return d && isFunction(d.dispose); + }; + var checkDisposed = Disposable.checkDisposed = function(disposable) { + if (disposable.isDisposed) { + throw new ObjectDisposedError(); + } + }; + var SingleAssignmentDisposable = Rx.SingleAssignmentDisposable = (function() { + function BooleanDisposable() { + this.isDisposed = false; + this.current = null; + } + var booleanDisposablePrototype = BooleanDisposable.prototype; + booleanDisposablePrototype.getDisposable = function() { + return this.current; }; - VirtualTimeSchedulerPrototype.advanceBy = function(time) { - var dt = this.add(this.clock, time), - dueToClock = this.comparer(this.clock, dt); - if (dueToClock > 0) { - throw new ArgumentOutOfRangeError(); - } - if (dueToClock === 0) { - return ; + booleanDisposablePrototype.setDisposable = function(value) { + var shouldDispose = this.isDisposed; + if (!shouldDispose) { + var old = this.current; + this.current = value; } - this.advanceTo(dt); + old && old.dispose(); + shouldDispose && value && value.dispose(); }; - VirtualTimeSchedulerPrototype.sleep = function(time) { - var dt = this.add(this.clock, time); - if (this.comparer(this.clock, dt) >= 0) { - throw new ArgumentOutOfRangeError(); + booleanDisposablePrototype.dispose = function() { + if (!this.isDisposed) { + this.isDisposed = true; + var old = this.current; + this.current = null; } - this.clock = dt; + old && old.dispose(); }; - VirtualTimeSchedulerPrototype.getNext = function() { - while (this.queue.length > 0) { - var next = this.queue.peek(); - if (next.isCancelled()) { - this.queue.dequeue(); - } else { - return next; + return BooleanDisposable; + }()); + var SerialDisposable = Rx.SerialDisposable = SingleAssignmentDisposable; + var RefCountDisposable = Rx.RefCountDisposable = (function() { + function InnerDisposable(disposable) { + this.disposable = disposable; + this.disposable.count++; + this.isInnerDisposed = false; + } + InnerDisposable.prototype.dispose = function() { + if (!this.disposable.isDisposed && !this.isInnerDisposed) { + this.isInnerDisposed = true; + this.disposable.count--; + if (this.disposable.count === 0 && this.disposable.isPrimaryDisposed) { + this.disposable.isDisposed = true; + this.disposable.underlyingDisposable.dispose(); } } - return null; - }; - VirtualTimeSchedulerPrototype.scheduleAbsolute = function(dueTime, action) { - return this.scheduleAbsoluteWithState(action, dueTime, invokeAction); - }; - VirtualTimeSchedulerPrototype.scheduleAbsoluteWithState = function(state, dueTime, action) { - var self = this; - function run(scheduler, state1) { - self.queue.remove(si); - return action(scheduler, state1); - } - var si = new ScheduledItem(this, state, run, dueTime, this.comparer); - this.queue.enqueue(si); - return si.disposable; - }; - return VirtualTimeScheduler; - }(Scheduler)); - Rx.HistoricalScheduler = (function(__super__) { - inherits(HistoricalScheduler, __super__); - function HistoricalScheduler(initialClock, comparer) { - var clock = initialClock == null ? 0 : initialClock; - var cmp = comparer || defaultSubComparer; - __super__.call(this, clock, cmp); - } - var HistoricalSchedulerProto = HistoricalScheduler.prototype; - HistoricalSchedulerProto.add = function(absolute, relative) { - return absolute + relative; - }; - HistoricalSchedulerProto.toDateTimeOffset = function(absolute) { - return new Date(absolute).getTime(); - }; - HistoricalSchedulerProto.toRelative = function(timeSpan) { - return timeSpan; }; - return HistoricalScheduler; - }(Rx.VirtualTimeScheduler)); - var AnonymousObservable = Rx.AnonymousObservable = (function(__super__) { - inherits(AnonymousObservable, __super__); - function fixSubscriber(subscriber) { - return subscriber && isFunction(subscriber.dispose) ? subscriber : isFunction(subscriber) ? disposableCreate(subscriber) : disposableEmpty; + function RefCountDisposable(disposable) { + this.underlyingDisposable = disposable; + this.isDisposed = false; + this.isPrimaryDisposed = false; + this.count = 0; } - function setDisposable(s, state) { - var ado = state[0], - subscribe = state[1]; - var sub = tryCatch(subscribe)(ado); - if (sub === errorObj) { - if (!ado.fail(errorObj.e)) { - return thrower(errorObj.e); + RefCountDisposable.prototype.dispose = function() { + if (!this.isDisposed && !this.isPrimaryDisposed) { + this.isPrimaryDisposed = true; + if (this.count === 0) { + this.isDisposed = true; + this.underlyingDisposable.dispose(); } } - ado.setDisposable(fixSubscriber(sub)); + }; + RefCountDisposable.prototype.getDisposable = function() { + return this.isDisposed ? disposableEmpty : new InnerDisposable(this); + }; + return RefCountDisposable; + })(); + function ScheduledDisposable(scheduler, disposable) { + this.scheduler = scheduler; + this.disposable = disposable; + this.isDisposed = false; + } + function scheduleItem(s, self) { + if (!self.isDisposed) { + self.isDisposed = true; + self.disposable.dispose(); } - function AnonymousObservable(subscribe, parent) { - this.source = parent; - function s(observer) { - var ado = new AutoDetachObserver(observer), - state = [ado, subscribe]; - if (currentThreadScheduler.scheduleRequired()) { - currentThreadScheduler.scheduleWithState(state, setDisposable); - } else { - setDisposable(null, state); - } - return ado; - } - __super__.call(this, s); + } + ScheduledDisposable.prototype.dispose = function() { + this.scheduler.scheduleWithState(this, scheduleItem); + }; + var ScheduledItem = Rx.internals.ScheduledItem = function(scheduler, state, action, dueTime, comparer) { + this.scheduler = scheduler; + this.state = state; + this.action = action; + this.dueTime = dueTime; + this.comparer = comparer || defaultSubComparer; + this.disposable = new SingleAssignmentDisposable(); + }; + ScheduledItem.prototype.invoke = function() { + this.disposable.setDisposable(this.invokeCore()); + }; + ScheduledItem.prototype.compareTo = function(other) { + return this.comparer(this.dueTime, other.dueTime); + }; + ScheduledItem.prototype.isCancelled = function() { + return this.disposable.isDisposed; + }; + ScheduledItem.prototype.invokeCore = function() { + return this.action(this.scheduler, this.state); + }; + var Scheduler = Rx.Scheduler = (function() { + function Scheduler(now, schedule, scheduleRelative, scheduleAbsolute) { + this.now = now; + this._schedule = schedule; + this._scheduleRelative = scheduleRelative; + this._scheduleAbsolute = scheduleAbsolute; } - return AnonymousObservable; - }(Observable)); - var AutoDetachObserver = (function(__super__) { - inherits(AutoDetachObserver, __super__); - function AutoDetachObserver(observer) { - __super__.call(this); - this.observer = observer; - this.m = new SingleAssignmentDisposable(); + function invokeAction(scheduler, action) { + action(); + return disposableEmpty; } - var AutoDetachObserverPrototype = AutoDetachObserver.prototype; - AutoDetachObserverPrototype.next = function(value) { - var result = tryCatch(this.observer.onNext).call(this.observer, value); - if (result === errorObj) { - this.dispose(); - thrower(result.e); - } + var schedulerProto = Scheduler.prototype; + schedulerProto.schedule = function(action) { + return this._schedule(action, invokeAction); }; - AutoDetachObserverPrototype.error = function(err) { - var result = tryCatch(this.observer.onError).call(this.observer, err); - this.dispose(); - result === errorObj && thrower(result.e); + schedulerProto.scheduleWithState = function(state, action) { + return this._schedule(state, action); }; - AutoDetachObserverPrototype.completed = function() { - var result = tryCatch(this.observer.onCompleted).call(this.observer); - this.dispose(); - result === errorObj && thrower(result.e); + schedulerProto.scheduleWithRelative = function(dueTime, action) { + return this._scheduleRelative(action, dueTime, invokeAction); }; - AutoDetachObserverPrototype.setDisposable = function(value) { - this.m.setDisposable(value); + schedulerProto.scheduleWithRelativeAndState = function(state, dueTime, action) { + return this._scheduleRelative(state, dueTime, action); }; - AutoDetachObserverPrototype.getDisposable = function() { - return this.m.getDisposable(); + schedulerProto.scheduleWithAbsolute = function(dueTime, action) { + return this._scheduleAbsolute(action, dueTime, invokeAction); }; - AutoDetachObserverPrototype.dispose = function() { - __super__.prototype.dispose.call(this); - this.m.dispose(); + schedulerProto.scheduleWithAbsoluteAndState = function(state, dueTime, action) { + return this._scheduleAbsolute(state, dueTime, action); }; - return AutoDetachObserver; - }(AbstractObserver)); - var GroupedObservable = (function(__super__) { - inherits(GroupedObservable, __super__); - function subscribe(observer) { - return this.underlyingObservable.subscribe(observer); - } - function GroupedObservable(key, underlyingObservable, mergedDisposable) { - __super__.call(this, subscribe); - this.key = key; - this.underlyingObservable = !mergedDisposable ? underlyingObservable : new AnonymousObservable(function(observer) { - return new CompositeDisposable(mergedDisposable.getDisposable(), underlyingObservable.subscribe(observer)); - }); - } - return GroupedObservable; - }(Observable)); - var Subject = Rx.Subject = (function(__super__) { - function subscribe(observer) { - checkDisposed(this); - if (!this.isStopped) { - this.observers.push(observer); - return new InnerSubscription(this, observer); - } - if (this.hasError) { - observer.onError(this.error); - return disposableEmpty; - } - observer.onCompleted(); - return disposableEmpty; - } - inherits(Subject, __super__); - function Subject() { - __super__.call(this, subscribe); - this.isDisposed = false, this.isStopped = false, this.observers = []; - this.hasError = false; - } - addProperties(Subject.prototype, Observer.prototype, { - hasObservers: function() { - return this.observers.length > 0; - }, - onCompleted: function() { - checkDisposed(this); - if (!this.isStopped) { - this.isStopped = true; - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - os[i].onCompleted(); - } - this.observers.length = 0; - } - }, - onError: function(error) { - checkDisposed(this); - if (!this.isStopped) { - this.isStopped = true; - this.error = error; - this.hasError = true; - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - os[i].onError(error); - } - this.observers.length = 0; - } - }, - onNext: function(value) { - checkDisposed(this); - if (!this.isStopped) { - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - os[i].onNext(value); - } - } - }, - dispose: function() { - this.isDisposed = true; - this.observers = null; - } - }); - Subject.create = function(observer, observable) { - return new AnonymousSubject(observer, observable); + Scheduler.now = defaultNow; + Scheduler.normalize = function(timeSpan) { + timeSpan < 0 && (timeSpan = 0); + return timeSpan; }; - return Subject; - }(Observable)); - var AsyncSubject = Rx.AsyncSubject = (function(__super__) { - function subscribe(observer) { - checkDisposed(this); - if (!this.isStopped) { - this.observers.push(observer); - return new InnerSubscription(this, observer); - } - if (this.hasError) { - observer.onError(this.error); - } else if (this.hasValue) { - observer.onNext(this.value); - observer.onCompleted(); - } else { - observer.onCompleted(); + return Scheduler; + }()); + var normalizeTime = Scheduler.normalize; + (function(schedulerProto) { + function invokeRecImmediate(scheduler, pair) { + var state = pair[0], + action = pair[1], + group = new CompositeDisposable(); + function recursiveAction(state1) { + action(state1, function(state2) { + var isAdded = false, + isDone = false, + d = scheduler.scheduleWithState(state2, function(scheduler1, state3) { + if (isAdded) { + group.remove(d); + } else { + isDone = true; + } + recursiveAction(state3); + return disposableEmpty; + }); + if (!isDone) { + group.add(d); + isAdded = true; + } + }); } - return disposableEmpty; - } - inherits(AsyncSubject, __super__); - function AsyncSubject() { - __super__.call(this, subscribe); - this.isDisposed = false; - this.isStopped = false; - this.hasValue = false; - this.observers = []; - this.hasError = false; + recursiveAction(state); + return group; } - addProperties(AsyncSubject.prototype, Observer, { - hasObservers: function() { - checkDisposed(this); - return this.observers.length > 0; - }, - onCompleted: function() { - var i, - len; - checkDisposed(this); - if (!this.isStopped) { - this.isStopped = true; - var os = cloneArray(this.observers), - len = os.length; - if (this.hasValue) { - for (i = 0; i < len; i++) { - var o = os[i]; - o.onNext(this.value); - o.onCompleted(); - } - } else { - for (i = 0; i < len; i++) { - os[i].onCompleted(); - } - } - this.observers.length = 0; - } - }, - onError: function(error) { - checkDisposed(this); - if (!this.isStopped) { - this.isStopped = true; - this.hasError = true; - this.error = error; - for (var i = 0, - os = cloneArray(this.observers), - len = os.length; i < len; i++) { - os[i].onError(error); - } - this.observers.length = 0; - } - }, - onNext: function(value) { - checkDisposed(this); - if (this.isStopped) { - return ; - } - this.value = value; - this.hasValue = true; - }, - dispose: function() { - this.isDisposed = true; - this.observers = null; - this.exception = null; - this.value = null; + function invokeRecDate(scheduler, pair, method) { + var state = pair[0], + action = pair[1], + group = new CompositeDisposable(); + function recursiveAction(state1) { + action(state1, function(state2, dueTime1) { + var isAdded = false, + isDone = false, + d = scheduler[method](state2, dueTime1, function(scheduler1, state3) { + if (isAdded) { + group.remove(d); + } else { + isDone = true; + } + recursiveAction(state3); + return disposableEmpty; + }); + if (!isDone) { + group.add(d); + isAdded = true; + } + }); } - }); - return AsyncSubject; - }(Observable)); - var AnonymousSubject = Rx.AnonymousSubject = (function(__super__) { - inherits(AnonymousSubject, __super__); - function subscribe(observer) { - return this.observable.subscribe(observer); + ; + recursiveAction(state); + return group; } - function AnonymousSubject(observer, observable) { - this.observer = observer; - this.observable = observable; - __super__.call(this, subscribe); + function scheduleInnerRecursive(action, self) { + action(function(dt) { + self(action, dt); + }); } - addProperties(AnonymousSubject.prototype, Observer.prototype, { - onCompleted: function() { - this.observer.onCompleted(); - }, - onError: function(error) { - this.observer.onError(error); - }, - onNext: function(value) { - this.observer.onNext(value); + schedulerProto.scheduleRecursive = function(action) { + return this.scheduleRecursiveWithState(action, function(_action, self) { + _action(function() { + self(_action); + }); + }); + }; + schedulerProto.scheduleRecursiveWithState = function(state, action) { + return this.scheduleWithState([state, action], invokeRecImmediate); + }; + schedulerProto.scheduleRecursiveWithRelative = function(dueTime, action) { + return this.scheduleRecursiveWithRelativeAndState(action, dueTime, scheduleInnerRecursive); + }; + schedulerProto.scheduleRecursiveWithRelativeAndState = function(state, dueTime, action) { + return this._scheduleRelative([state, action], dueTime, function(s, p) { + return invokeRecDate(s, p, 'scheduleWithRelativeAndState'); + }); + }; + schedulerProto.scheduleRecursiveWithAbsolute = function(dueTime, action) { + return this.scheduleRecursiveWithAbsoluteAndState(action, dueTime, scheduleInnerRecursive); + }; + schedulerProto.scheduleRecursiveWithAbsoluteAndState = function(state, dueTime, action) { + return this._scheduleAbsolute([state, action], dueTime, function(s, p) { + return invokeRecDate(s, p, 'scheduleWithAbsoluteAndState'); + }); + }; + }(Scheduler.prototype)); + (function(schedulerProto) { + Scheduler.prototype.schedulePeriodic = function(period, action) { + return this.schedulePeriodicWithState(null, period, action); + }; + Scheduler.prototype.schedulePeriodicWithState = function(state, period, action) { + if (typeof root.setInterval === 'undefined') { + throw new NotSupportedError(); } - }); - return AnonymousSubject; - }(Observable)); - Rx.Pauser = (function(__super__) { - inherits(Pauser, __super__); - function Pauser() { - __super__.call(this); - } - Pauser.prototype.pause = function() { - this.onNext(false); + period = normalizeTime(period); + var s = state, + id = root.setInterval(function() { + s = action(s); + }, period); + return disposableCreate(function() { + root.clearInterval(id); + }); }; - Pauser.prototype.resume = function() { - this.onNext(true); + }(Scheduler.prototype)); + (function(schedulerProto) { + schedulerProto.catchError = schedulerProto['catch'] = function(handler) { + return new CatchScheduler(this, handler); }; - return Pauser; - }(Subject)); - if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) { - root.Rx = Rx; - define(function() { - return Rx; - }); - } else if (freeExports && freeModule) { - if (moduleExports) { - (freeModule.exports = Rx).Rx = Rx; - } else { - freeExports.Rx = Rx; - } - } else { - root.Rx = Rx; - } - var rEndingLine = captureLine(); - }.call(this)); - global.define = __define; - return module.exports; -}); - -System.register("rtts_assert/src/rtts_assert", [], function($__export) { - "use strict"; - var __moduleName = "rtts_assert/src/rtts_assert"; - var _global, - POSITION_NAME, - primitives, - genericType, - string, - boolean, - number, - currentStack, - prop; - function argPositionName(i) { - var position = (i / 2) + 1; - return POSITION_NAME[position] || (position + 'th'); - } - function proxy() {} - function assertArgumentTypes() { - for (var params = [], - $__0 = 0; $__0 < arguments.length; $__0++) - params[$__0] = arguments[$__0]; - var actual, - type; - var currentArgErrors; - var errors = []; - var msg; - for (var i = 0, - l = params.length; i < l; i = i + 2) { - actual = params[i]; - type = params[i + 1]; - currentArgErrors = []; - if (!isType(actual, type, currentArgErrors)) { - errors.push(argPositionName(i) + ' argument has to be an instance of ' + prettyPrint(type) + ', got ' + prettyPrint(actual)); - if (currentArgErrors.length) { - errors.push(currentArgErrors); + }(Scheduler.prototype)); + var SchedulePeriodicRecursive = Rx.internals.SchedulePeriodicRecursive = (function() { + function tick(command, recurse) { + recurse(0, this._period); + try { + this._state = this._action(this._state); + } catch (e) { + this._cancel.dispose(); + throw e; } } - } - if (errors.length) { - throw new Error('Invalid arguments given!\n' + formatErrors(errors)); - } - } - function prettyPrint(value, depth) { - if (typeof(depth) === 'undefined') { - depth = 0; - } - if (depth++ > 3) { - return '[...]'; - } - if (typeof value === 'undefined') { - return 'undefined'; - } - if (typeof value === 'string') { - return '"' + value + '"'; - } - if (typeof value === 'boolean') { - return value.toString(); - } - if (value === null) { - return 'null'; - } - if (typeof value === 'object') { - if (value.__assertName) { - return value.__assertName; - } - if (value.map && typeof value.map === 'function') { - return '[' + value.map((function(v) { - return prettyPrint(v, depth); - })).join(', ') + ']'; - } - var properties = Object.keys(value); - var suffix = '}'; - if (properties.length > 20) { - properties.length = 20; - suffix = ', ... }'; + function SchedulePeriodicRecursive(scheduler, state, period, action) { + this._scheduler = scheduler; + this._state = state; + this._period = period; + this._action = action; } - return '{' + properties.map((function(p) { - return p + ': ' + prettyPrint(value[p], depth); - })).join(', ') + suffix; - } - return value.__assertName || value.name || value.toString(); - } - function isType(value, T, errors) { - if (T && T.type) { - T = T.type; - } - if (T === primitives.void) { - return typeof value === 'undefined'; - } - if (_isProxy(value)) { - return true; - } - if (T === primitives.any || value === null) { - return true; - } - if (T === primitives.string) { - return typeof value === 'string'; - } - if (T === primitives.number) { - return typeof value === 'number'; - } - if (T === primitives.boolean) { - return typeof value === 'boolean'; - } - if (typeof T.assert === 'function') { - var parentStack = currentStack; - var isValid; - currentStack = errors; - try { - isValid = T.assert(value); - } catch (e) { - fail(e.message); - isValid = false; + SchedulePeriodicRecursive.prototype.start = function() { + var d = new SingleAssignmentDisposable(); + this._cancel = d; + d.setDisposable(this._scheduler.scheduleRecursiveWithRelativeAndState(0, this._period, tick.bind(this))); + return d; + }; + return SchedulePeriodicRecursive; + }()); + var immediateScheduler = Scheduler.immediate = (function() { + function scheduleNow(state, action) { + return action(this, state); } - currentStack = parentStack; - if (typeof isValid === 'undefined') { - isValid = errors.length === 0; + return new Scheduler(defaultNow, scheduleNow, notSupported, notSupported); + }()); + var currentThreadScheduler = Scheduler.currentThread = (function() { + var queue; + function runTrampoline() { + while (queue.length > 0) { + var item = queue.dequeue(); + !item.isCancelled() && item.invoke(); + } } - return isValid; - } - return value instanceof T; - } - function _isProxy(obj) { - if (!obj || !obj.constructor || !obj.constructor.annotations) - return false; - return obj.constructor.annotations.filter((function(a) { - return a instanceof proxy; - })).length > 0; - } - function formatErrors(errors) { - var indent = arguments[1] !== (void 0) ? arguments[1] : ' '; - return errors.map((function(e) { - if (typeof e === 'string') - return indent + '- ' + e; - return formatErrors(e, indent + ' '); - })).join('\n'); - } - function type(actual, T) { - var errors = []; - if (!isType(actual, T, errors)) { - var msg = 'Expected an instance of ' + prettyPrint(T) + ', got ' + prettyPrint(actual) + '!'; - if (errors.length) { - msg += '\n' + formatErrors(errors); + function scheduleNow(state, action) { + var si = new ScheduledItem(this, state, action, this.now()); + if (!queue) { + queue = new PriorityQueue(4); + queue.enqueue(si); + var result = tryCatch(runTrampoline)(); + queue = null; + if (result === errorObj) { + return thrower(result.e); + } + } else { + queue.enqueue(si); + } + return si.disposable; } - throw new Error(msg); - } - return actual; - } - function returnType(actual, T) { - var errors = []; - if (!isType(actual, T, errors)) { - var msg = 'Expected to return an instance of ' + prettyPrint(T) + ', got ' + prettyPrint(actual) + '!'; - if (errors.length) { - msg += '\n' + formatErrors(errors); + var currentScheduler = new Scheduler(defaultNow, scheduleNow, notSupported, notSupported); + currentScheduler.scheduleRequired = function() { + return !queue; + }; + return currentScheduler; + }()); + var scheduleMethod, + clearMethod; + var localTimer = (function() { + var localSetTimeout, + localClearTimeout = noop; + if (!!root.WScript) { + localSetTimeout = function(fn, time) { + root.WScript.Sleep(time); + fn(); + }; + } else if (!!root.setTimeout) { + localSetTimeout = root.setTimeout; + localClearTimeout = root.clearTimeout; + } else { + throw new NotSupportedError(); } - throw new Error(msg); - } - return actual; - } - function arrayOf() { - for (var types = [], - $__1 = 0; $__1 < arguments.length; $__1++) - types[$__1] = arguments[$__1]; - return assert.define('array of ' + types.map(prettyPrint).join('/'), function(value) { - var $__3; - if (assert(value).is(Array)) { - for (var i = 0; i < value.length; i++) { - ($__3 = assert(value[i])).is.apply($__3, $traceurRuntime.spread(types)); + return { + setTimeout: localSetTimeout, + clearTimeout: localClearTimeout + }; + }()); + var localSetTimeout = localTimer.setTimeout, + localClearTimeout = localTimer.clearTimeout; + (function() { + var nextHandle = 1, + tasksByHandle = {}, + currentlyRunning = false; + clearMethod = function(handle) { + delete tasksByHandle[handle]; + }; + function runTask(handle) { + if (currentlyRunning) { + localSetTimeout(function() { + runTask(handle); + }, 0); + } else { + var task = tasksByHandle[handle]; + if (task) { + currentlyRunning = true; + var result = tryCatch(task)(); + clearMethod(handle); + currentlyRunning = false; + if (result === errorObj) { + return thrower(result.e); + } + } } } - }); - } - function structure(definition) { - var properties = Object.keys(definition); - return assert.define('object with properties ' + properties.join(', '), function(value) { - if (assert(value).is(Object)) { - for (var i = 0; i < properties.length; i++) { - var property = properties[i]; - assert(value[property]).is(definition[property]); + var reNative = RegExp('^' + String(toString).replace(/[.*+?^${}()|[\]\\]/g, '\\$&').replace(/toString| for [^\]]+/g, '.*?') + '$'); + var setImmediate = typeof(setImmediate = freeGlobal && moduleExports && freeGlobal.setImmediate) == 'function' && !reNative.test(setImmediate) && setImmediate; + function postMessageSupported() { + if (!root.postMessage || root.importScripts) { + return false; } - } - }); - } - function fail(message) { - currentStack.push(message); - } - function define(classOrName, check) { - var cls = classOrName; - if (typeof classOrName === 'string') { - cls = function() {}; - cls.__assertName = classOrName; - } - cls.assert = function(value) { - return check(value); - }; - return cls; - } - function assert(value) { - return {is: function is() { - var $__3; - for (var types = [], - $__2 = 0; $__2 < arguments.length; $__2++) - types[$__2] = arguments[$__2]; - var allErrors = []; - var errors; - for (var i = 0; i < types.length; i++) { - var type = types[i]; - errors = []; - if (isType(value, type, errors)) { - return true; - } - allErrors.push(prettyPrint(value) + ' is not instance of ' + prettyPrint(type)); - if (errors.length) { - allErrors.push(errors); + var isAsync = false, + oldHandler = root.onmessage; + root.onmessage = function() { + isAsync = true; + }; + root.postMessage('', '*'); + root.onmessage = oldHandler; + return isAsync; + } + if (isFunction(setImmediate)) { + scheduleMethod = function(action) { + var id = nextHandle++; + tasksByHandle[id] = action; + setImmediate(function() { + runTask(id); + }); + return id; + }; + } else if (typeof process !== 'undefined' && {}.toString.call(process) === '[object process]') { + scheduleMethod = function(action) { + var id = nextHandle++; + tasksByHandle[id] = action; + process.nextTick(function() { + runTask(id); + }); + return id; + }; + } else if (postMessageSupported()) { + var MSG_PREFIX = 'ms.rx.schedule' + Math.random(); + function onGlobalPostMessage(event) { + if (typeof event.data === 'string' && event.data.substring(0, MSG_PREFIX.length) === MSG_PREFIX) { + runTask(event.data.substring(MSG_PREFIX.length)); } } - ($__3 = currentStack).push.apply($__3, $traceurRuntime.spread(allErrors)); - return false; - }}; - } - $__export("proxy", proxy); - return { - setters: [], - execute: function() { - _global = typeof window === 'object' ? window : global; - POSITION_NAME = ['', '1st', '2nd', '3rd']; - if (typeof $traceurRuntime === 'object') { - primitives = $traceurRuntime.type; - genericType = $traceurRuntime.genericType; - } else { - primitives = { - any: {name: 'any'}, - boolean: {name: 'boolean'}, - number: {name: 'number'}, - string: {name: 'string'}, - symbol: {name: 'symbol'}, - void: {name: 'void'} + if (root.addEventListener) { + root.addEventListener('message', onGlobalPostMessage, false); + } else { + root.attachEvent('onmessage', onGlobalPostMessage, false); + } + scheduleMethod = function(action) { + var id = nextHandle++; + tasksByHandle[id] = action; + root.postMessage(MSG_PREFIX + currentId, '*'); + return id; }; - genericType = function(type, args) { - return { - type: type, - args: args + } else if (!!root.MessageChannel) { + var channel = new root.MessageChannel(); + channel.port1.onmessage = function(e) { + runTask(e.data); + }; + scheduleMethod = function(action) { + var id = nextHandle++; + tasksByHandle[id] = action; + channel.port2.postMessage(id); + return id; + }; + } else if ('document' in root && 'onreadystatechange' in root.document.createElement('script')) { + scheduleMethod = function(action) { + var scriptElement = root.document.createElement('script'); + var id = nextHandle++; + tasksByHandle[id] = action; + scriptElement.onreadystatechange = function() { + runTask(id); + scriptElement.onreadystatechange = null; + scriptElement.parentNode.removeChild(scriptElement); + scriptElement = null; }; + root.document.documentElement.appendChild(scriptElement); + return id; }; - } - Object.keys(primitives).forEach(function(name) { - primitives[name].__assertName = name; - }); - string = type.string = define('string', function(value) { - return typeof value === 'string'; - }); - boolean = type.boolean = define('boolean', function(value) { - return typeof value === 'boolean'; - }); - number = type.number = define('number', function(value) { - return typeof value === 'number'; - }); - currentStack = []; - assert.type = type; - for (prop in primitives) { - assert.type[prop] = primitives[prop]; - } - assert.genericType = genericType; - assert.argumentTypes = assertArgumentTypes; - assert.returnType = returnType; - assert.define = define; - assert.fail = fail; - assert.string = string; - assert.number = number; - assert.boolean = boolean; - assert.arrayOf = arrayOf; - assert.structure = structure; - $__export("assert", assert); - } - }; -}); - -System.register("angular2/src/facade/lang", ["rtts_assert/rtts_assert"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/facade/lang"; - var assert, - _global, - Type, - Math, - Date, - assertionsEnabled_, - int, - CONST, - ABSTRACT, - IMPLEMENTS, - StringWrapper, - StringJoiner, - NumberParseError, - NumberWrapper, - RegExp, - RegExpWrapper, - RegExpMatcherWrapper, - FunctionWrapper, - BaseException, - Json, - DateWrapper; - function isPresent(obj) { - return assert.returnType((obj !== undefined && obj !== null), assert.type.boolean); - } - function isBlank(obj) { - return assert.returnType((obj === undefined || obj === null), assert.type.boolean); - } - function isString(obj) { - return assert.returnType((typeof obj === "string"), assert.type.boolean); - } - function isFunction(obj) { - return assert.returnType((typeof obj === "function"), assert.type.boolean); - } - function isType(obj) { - return assert.returnType((isFunction(obj)), assert.type.boolean); - } - function stringify(token) { - if (typeof token === 'string') { - return assert.returnType((token), assert.type.string); - } - if (token === undefined || token === null) { - return assert.returnType(('' + token), assert.type.string); - } - if (token.name) { - return assert.returnType((token.name), assert.type.string); - } - return assert.returnType((token.toString()), assert.type.string); - } - function looseIdentical(a, b) { - return assert.returnType((a === b || typeof a === "number" && typeof b === "number" && isNaN(a) && isNaN(b)), assert.type.boolean); - } - function getMapKey(value) { - return value; - } - function normalizeBlank(obj) { - return isBlank(obj) ? null : obj; - } - function isJsObject(o) { - return assert.returnType((o !== null && (typeof o === "function" || typeof o === "object")), assert.type.boolean); - } - function assertionsEnabled() { - return assert.returnType((assertionsEnabled_), assert.type.boolean); - } - function print(obj) { - if (obj instanceof Error) { - console.log(obj.stack); - } else { - console.log(obj); - } - } - $__export("isPresent", isPresent); - $__export("isBlank", isBlank); - $__export("isString", isString); - $__export("isFunction", isFunction); - $__export("isType", isType); - $__export("stringify", stringify); - $__export("looseIdentical", looseIdentical); - $__export("getMapKey", getMapKey); - $__export("normalizeBlank", normalizeBlank); - $__export("isJsObject", isJsObject); - $__export("assertionsEnabled", assertionsEnabled); - $__export("print", print); - return { - setters: [function($__m) { - assert = $__m.assert; - }], - execute: function() { - _global = typeof window === 'undefined' ? global : window; - $__export("global", _global); - Type = Function; - $__export("Type", Type); - Math = _global.Math; - $__export("Math", Math); - Date = _global.Date; - $__export("Date", Date); - assertionsEnabled_ = typeof assert !== 'undefined'; - if (assertionsEnabled_) { - _global.assert = assert; - $__export("int", int = assert.define('int', function(value) { - return typeof value === 'number' && value % 1 === 0; - })); } else { - $__export("int", int = {}); - _global.assert = function() {}; + scheduleMethod = function(action) { + var id = nextHandle++; + tasksByHandle[id] = action; + localSetTimeout(function() { + runTask(id); + }, 0); + return id; + }; } - $__export("int", int); - CONST = (function() { - function CONST() {} - return ($traceurRuntime.createClass)(CONST, {}, {}); - }()); - $__export("CONST", CONST); - ABSTRACT = (function() { - function ABSTRACT() {} - return ($traceurRuntime.createClass)(ABSTRACT, {}, {}); - }()); - $__export("ABSTRACT", ABSTRACT); - IMPLEMENTS = (function() { - function IMPLEMENTS() {} - return ($traceurRuntime.createClass)(IMPLEMENTS, {}, {}); - }()); - $__export("IMPLEMENTS", IMPLEMENTS); - StringWrapper = (function() { - function StringWrapper() {} - return ($traceurRuntime.createClass)(StringWrapper, {}, { - fromCharCode: function(code) { - assert.argumentTypes(code, int); - return assert.returnType((String.fromCharCode(code)), assert.type.string); - }, - charCodeAt: function(s, index) { - assert.argumentTypes(s, assert.type.string, index, int); - return s.charCodeAt(index); - }, - split: function(s, regExp) { - assert.argumentTypes(s, assert.type.string, regExp, assert.type.any); - return s.split(regExp); - }, - equals: function(s, s2) { - assert.argumentTypes(s, assert.type.string, s2, assert.type.string); - return assert.returnType((s === s2), assert.type.boolean); - }, - replace: function(s, from, replace) { - assert.argumentTypes(s, assert.type.string, from, assert.type.string, replace, assert.type.string); - return assert.returnType((s.replace(from, replace)), assert.type.string); - }, - replaceAll: function(s, from, replace) { - assert.argumentTypes(s, assert.type.string, from, RegExp, replace, assert.type.string); - return assert.returnType((s.replace(from, replace)), assert.type.string); - }, - startsWith: function(s, start) { - assert.argumentTypes(s, assert.type.string, start, assert.type.string); - return s.startsWith(start); - }, - substring: function(s, start) { - var end = arguments[2] !== (void 0) ? arguments[2] : null; - assert.argumentTypes(s, assert.type.string, start, int, end, int); - return s.substring(start, end === null ? undefined : end); - }, - replaceAllMapped: function(s, from, cb) { - assert.argumentTypes(s, assert.type.string, from, RegExp, cb, Function); - return assert.returnType((s.replace(from, function() { - for (var matches = [], - $__1 = 0; $__1 < arguments.length; $__1++) - matches[$__1] = arguments[$__1]; - matches.splice(-2, 2); - return cb(matches); - })), assert.type.string); - }, - contains: function(s, substr) { - assert.argumentTypes(s, assert.type.string, substr, assert.type.string); - return assert.returnType((s.indexOf(substr) != -1), assert.type.boolean); - } - }); - }()); - $__export("StringWrapper", StringWrapper); - Object.defineProperty(StringWrapper.fromCharCode, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(StringWrapper.charCodeAt, "parameters", {get: function() { - return [[assert.type.string], [int]]; - }}); - Object.defineProperty(StringWrapper.split, "parameters", {get: function() { - return [[assert.type.string], []]; - }}); - Object.defineProperty(StringWrapper.equals, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(StringWrapper.replace, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(StringWrapper.replaceAll, "parameters", {get: function() { - return [[assert.type.string], [RegExp], [assert.type.string]]; - }}); - Object.defineProperty(StringWrapper.startsWith, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(StringWrapper.substring, "parameters", {get: function() { - return [[assert.type.string], [int], [int]]; - }}); - Object.defineProperty(StringWrapper.replaceAllMapped, "parameters", {get: function() { - return [[assert.type.string], [RegExp], [Function]]; - }}); - Object.defineProperty(StringWrapper.contains, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - StringJoiner = (function() { - function StringJoiner() { - this.parts = []; - } - return ($traceurRuntime.createClass)(StringJoiner, { - add: function(part) { - assert.argumentTypes(part, assert.type.string); - this.parts.push(part); - }, - toString: function() { - return assert.returnType((this.parts.join("")), assert.type.string); + }()); + var timeoutScheduler = Scheduler.timeout = Scheduler.default = (function() { + function scheduleNow(state, action) { + var scheduler = this, + disposable = new SingleAssignmentDisposable(); + var id = scheduleMethod(function() { + if (!disposable.isDisposed) { + disposable.setDisposable(action(scheduler, state)); } - }, {}); - }()); - $__export("StringJoiner", StringJoiner); - Object.defineProperty(StringJoiner.prototype.add, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - NumberParseError = (function($__super) { - function NumberParseError(message) { - $traceurRuntime.superConstructor(NumberParseError).call(this); - this.message = message; + }); + return new CompositeDisposable(disposable, disposableCreate(function() { + clearMethod(id); + })); + } + function scheduleRelative(state, dueTime, action) { + var scheduler = this, + dt = Scheduler.normalize(dueTime); + if (dt === 0) { + return scheduler.scheduleWithState(state, action); } - return ($traceurRuntime.createClass)(NumberParseError, {toString: function() { - return this.message; - }}, {}, $__super); - }(Error)); - $__export("NumberParseError", NumberParseError); - NumberWrapper = (function() { - function NumberWrapper() {} - return ($traceurRuntime.createClass)(NumberWrapper, {}, { - toFixed: function(n, fractionDigits) { - assert.argumentTypes(n, assert.type.number, fractionDigits, int); - return assert.returnType((n.toFixed(fractionDigits)), assert.type.string); - }, - equal: function(a, b) { - return assert.returnType((a === b), assert.type.boolean); - }, - parseIntAutoRadix: function(text) { - assert.argumentTypes(text, assert.type.string); - var result = assert.type(parseInt(text), int); - if (isNaN(result)) { - throw new NumberParseError("Invalid integer literal when parsing " + text); + var disposable = new SingleAssignmentDisposable(); + var id = localSetTimeout(function() { + if (!disposable.isDisposed) { + disposable.setDisposable(action(scheduler, state)); + } + }, dt); + return new CompositeDisposable(disposable, disposableCreate(function() { + localClearTimeout(id); + })); + } + function scheduleAbsolute(state, dueTime, action) { + return this.scheduleWithRelativeAndState(state, dueTime - this.now(), action); + } + return new Scheduler(defaultNow, scheduleNow, scheduleRelative, scheduleAbsolute); + })(); + var CatchScheduler = (function(__super__) { + function scheduleNow(state, action) { + return this._scheduler.scheduleWithState(state, this._wrap(action)); + } + function scheduleRelative(state, dueTime, action) { + return this._scheduler.scheduleWithRelativeAndState(state, dueTime, this._wrap(action)); + } + function scheduleAbsolute(state, dueTime, action) { + return this._scheduler.scheduleWithAbsoluteAndState(state, dueTime, this._wrap(action)); + } + inherits(CatchScheduler, __super__); + function CatchScheduler(scheduler, handler) { + this._scheduler = scheduler; + this._handler = handler; + this._recursiveOriginal = null; + this._recursiveWrapper = null; + __super__.call(this, this._scheduler.now.bind(this._scheduler), scheduleNow, scheduleRelative, scheduleAbsolute); + } + CatchScheduler.prototype._clone = function(scheduler) { + return new CatchScheduler(scheduler, this._handler); + }; + CatchScheduler.prototype._wrap = function(action) { + var parent = this; + return function(self, state) { + try { + return action(parent._getRecursiveWrapper(self), state); + } catch (e) { + if (!parent._handler(e)) { + throw e; } - return assert.returnType((result), int); - }, - parseInt: function(text, radix) { - assert.argumentTypes(text, assert.type.string, radix, int); - if (radix == 10) { - if (/^(\-|\+)?[0-9]+$/.test(text)) { - return assert.returnType((parseInt(text, radix)), int); - } - } else if (radix == 16) { - if (/^(\-|\+)?[0-9ABCDEFabcdef]+$/.test(text)) { - return assert.returnType((parseInt(text, radix)), int); - } - } else { - var result = assert.type(parseInt(text, radix), int); - if (!isNaN(result)) { - return assert.returnType((result), int); - } + return disposableEmpty; + } + }; + }; + CatchScheduler.prototype._getRecursiveWrapper = function(scheduler) { + if (this._recursiveOriginal !== scheduler) { + this._recursiveOriginal = scheduler; + var wrapper = this._clone(scheduler); + wrapper._recursiveOriginal = scheduler; + wrapper._recursiveWrapper = wrapper; + this._recursiveWrapper = wrapper; + } + return this._recursiveWrapper; + }; + CatchScheduler.prototype.schedulePeriodicWithState = function(state, period, action) { + var self = this, + failed = false, + d = new SingleAssignmentDisposable(); + d.setDisposable(this._scheduler.schedulePeriodicWithState(state, period, function(state1) { + if (failed) { + return null; + } + try { + return action(state1); + } catch (e) { + failed = true; + if (!self._handler(e)) { + throw e; } - throw new NumberParseError("Invalid integer literal when parsing " + text + " in base " + radix); - }, - parseFloat: function(text) { - assert.argumentTypes(text, assert.type.string); - return assert.returnType((parseFloat(text)), assert.type.number); - }, - get NaN() { - return assert.returnType((NaN), assert.type.number); - }, - isNaN: function(value) { - return assert.returnType((isNaN(value)), assert.type.boolean); - }, - isInteger: function(value) { - return assert.returnType((Number.isInteger(value)), assert.type.boolean); + d.dispose(); + return null; } + })); + return d; + }; + return CatchScheduler; + }(Scheduler)); + var Notification = Rx.Notification = (function() { + function Notification(kind, value, exception, accept, acceptObservable, toString) { + this.kind = kind; + this.value = value; + this.exception = exception; + this._accept = accept; + this._acceptObservable = acceptObservable; + this.toString = toString; + } + Notification.prototype.accept = function(observerOrOnNext, onError, onCompleted) { + return observerOrOnNext && typeof observerOrOnNext === 'object' ? this._acceptObservable(observerOrOnNext) : this._accept(observerOrOnNext, onError, onCompleted); + }; + Notification.prototype.toObservable = function(scheduler) { + var self = this; + isScheduler(scheduler) || (scheduler = immediateScheduler); + return new AnonymousObservable(function(observer) { + return scheduler.scheduleWithState(self, function(_, notification) { + notification._acceptObservable(observer); + notification.kind === 'N' && observer.onCompleted(); + }); }); - }()); - $__export("NumberWrapper", NumberWrapper); - Object.defineProperty(NumberWrapper.toFixed, "parameters", {get: function() { - return [[assert.type.number], [int]]; - }}); - Object.defineProperty(NumberWrapper.parseIntAutoRadix, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(NumberWrapper.parseInt, "parameters", {get: function() { - return [[assert.type.string], [int]]; - }}); - Object.defineProperty(NumberWrapper.parseFloat, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - RegExp = _global.RegExp; - $__export("RegExp", RegExp); - RegExpWrapper = (function() { - function RegExpWrapper() {} - return ($traceurRuntime.createClass)(RegExpWrapper, {}, { - create: function(regExpStr) { - var flags = arguments[1] !== (void 0) ? arguments[1] : ''; - assert.argumentTypes(regExpStr, assert.type.any, flags, assert.type.string); - flags = flags.replace(/g/g, ''); - return assert.returnType((new _global.RegExp(regExpStr, flags + 'g')), RegExp); - }, - firstMatch: function(regExp, input) { - regExp.lastIndex = 0; - return regExp.exec(input); - }, - matcher: function(regExp, input) { - regExp.lastIndex = 0; - return { - re: regExp, - input: input - }; + }; + return Notification; + })(); + var notificationCreateOnNext = Notification.createOnNext = (function() { + function _accept(onNext) { + return onNext(this.value); + } + function _acceptObservable(observer) { + return observer.onNext(this.value); + } + function toString() { + return 'OnNext(' + this.value + ')'; + } + return function(value) { + return new Notification('N', value, null, _accept, _acceptObservable, toString); + }; + }()); + var notificationCreateOnError = Notification.createOnError = (function() { + function _accept(onNext, onError) { + return onError(this.exception); + } + function _acceptObservable(observer) { + return observer.onError(this.exception); + } + function toString() { + return 'OnError(' + this.exception + ')'; + } + return function(e) { + return new Notification('E', null, e, _accept, _acceptObservable, toString); + }; + }()); + var notificationCreateOnCompleted = Notification.createOnCompleted = (function() { + function _accept(onNext, onError, onCompleted) { + return onCompleted(); + } + function _acceptObservable(observer) { + return observer.onCompleted(); + } + function toString() { + return 'OnCompleted()'; + } + return function() { + return new Notification('C', null, null, _accept, _acceptObservable, toString); + }; + }()); + var Enumerator = Rx.internals.Enumerator = function(next) { + this._next = next; + }; + Enumerator.prototype.next = function() { + return this._next(); + }; + Enumerator.prototype[$iterator$] = function() { + return this; + }; + var Enumerable = Rx.internals.Enumerable = function(iterator) { + this._iterator = iterator; + }; + Enumerable.prototype[$iterator$] = function() { + return this._iterator(); + }; + Enumerable.prototype.concat = function() { + var sources = this; + return new AnonymousObservable(function(o) { + var e = sources[$iterator$](); + var isDisposed, + subscription = new SerialDisposable(); + var cancelable = immediateScheduler.scheduleRecursive(function(self) { + if (isDisposed) { + return ; + } + try { + var currentItem = e.next(); + } catch (ex) { + return o.onError(ex); } - }); - }()); - $__export("RegExpWrapper", RegExpWrapper); - Object.defineProperty(RegExpWrapper.create, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - RegExpMatcherWrapper = (function() { - function RegExpMatcherWrapper() {} - return ($traceurRuntime.createClass)(RegExpMatcherWrapper, {}, {next: function(matcher) { - return matcher.re.exec(matcher.input); - }}); - }()); - $__export("RegExpMatcherWrapper", RegExpMatcherWrapper); - FunctionWrapper = (function() { - function FunctionWrapper() {} - return ($traceurRuntime.createClass)(FunctionWrapper, {}, {apply: function(fn, posArgs) { - assert.argumentTypes(fn, Function, posArgs, assert.type.any); - return fn.apply(null, posArgs); - }}); - }()); - $__export("FunctionWrapper", FunctionWrapper); - Object.defineProperty(FunctionWrapper.apply, "parameters", {get: function() { - return [[Function], []]; - }}); - BaseException = Error; - $__export("BaseException", BaseException); - Json = _global.JSON; - $__export("Json", Json); - DateWrapper = (function() { - function DateWrapper() {} - return ($traceurRuntime.createClass)(DateWrapper, {}, { - fromMillis: function(ms) { - return new Date(ms); - }, - toMillis: function(date) { - assert.argumentTypes(date, Date); - return date.getTime(); - }, - now: function() { - return new Date(); - }, - toJson: function(date) { - return date.toJSON(); + if (currentItem.done) { + return o.onCompleted(); } + var currentValue = currentItem.value; + isPromise(currentValue) && (currentValue = observableFromPromise(currentValue)); + var d = new SingleAssignmentDisposable(); + subscription.setDisposable(d); + d.setDisposable(currentValue.subscribe(function(x) { + o.onNext(x); + }, function(err) { + o.onError(err); + }, self)); }); - }()); - $__export("DateWrapper", DateWrapper); - Object.defineProperty(DateWrapper.toMillis, "parameters", {get: function() { - return [[Date]]; - }}); - } - }; -}); - -System.register("angular2/src/facade/collection", ["rtts_assert/rtts_assert", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/facade/collection"; - var assert, - int, - isJsObject, - global, - List, - Map, - Set, - StringMap, - MapWrapper, - StringMapWrapper, - ListWrapper, - SetWrapper; - function isListLikeIterable(obj) { - if (!isJsObject(obj)) - return assert.returnType((false), assert.type.boolean); - return assert.returnType((ListWrapper.isList(obj) || (!(obj instanceof Map) && Symbol.iterator in obj)), assert.type.boolean); - } - function iterateListLike(obj, fn) { - assert.argumentTypes(obj, assert.type.any, fn, Function); - if (ListWrapper.isList(obj)) { - for (var i = 0; i < obj.length; i++) { - fn(obj[i]); - } - } else { - var iterator = obj[Symbol.iterator](); - var item; - while (!((item = iterator.next()).done)) { - fn(item.value); - } - } - } - $__export("isListLikeIterable", isListLikeIterable); - $__export("iterateListLike", iterateListLike); - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - int = $__m.int; - isJsObject = $__m.isJsObject; - global = $__m.global; - }], - execute: function() { - List = global.Array; - $__export("List", List); - Map = global.Map; - $__export("Map", Map); - Set = global.Set; - $__export("Set", Set); - StringMap = global.Object; - $__export("StringMap", StringMap); - MapWrapper = (function() { - function MapWrapper() {} - return ($traceurRuntime.createClass)(MapWrapper, {}, { - create: function() { - return assert.returnType((new Map()), Map); - }, - clone: function(m) { - assert.argumentTypes(m, Map); - return assert.returnType((new Map(m)), Map); - }, - createFromStringMap: function(stringMap) { - var result = MapWrapper.create(); - for (var prop in stringMap) { - MapWrapper.set(result, prop, stringMap[prop]); - } - return assert.returnType((result), Map); - }, - createFromPairs: function(pairs) { - assert.argumentTypes(pairs, List); - return assert.returnType((new Map(pairs)), Map); - }, - get: function(m, k) { - return m.get(k); - }, - set: function(m, k, v) { - m.set(k, v); - }, - contains: function(m, k) { - return m.has(k); - }, - forEach: function(m, fn) { - m.forEach(fn); - }, - size: function(m) { - return m.size; - }, - delete: function(m, k) { - m.delete(k); - }, - clear: function(m) { - m.clear(); - }, - clearValues: function(m) { - var keyIterator = m.keys(); - var k; - while (!((k = keyIterator.next()).done)) { - m.set(k.value, null); + return new CompositeDisposable(subscription, cancelable, disposableCreate(function() { + isDisposed = true; + })); + }); + }; + Enumerable.prototype.catchError = function() { + var sources = this; + return new AnonymousObservable(function(o) { + var e = sources[$iterator$](); + var isDisposed, + subscription = new SerialDisposable(); + var cancelable = immediateScheduler.scheduleRecursiveWithState(null, function(lastException, self) { + if (isDisposed) { + return ; + } + try { + var currentItem = e.next(); + } catch (ex) { + return observer.onError(ex); + } + if (currentItem.done) { + if (lastException !== null) { + o.onError(lastException); + } else { + o.onCompleted(); } - }, - iterable: function(m) { - return m; - }, - keys: function(m) { - return m.keys(); - }, - values: function(m) { - return m.values(); + return ; } + var currentValue = currentItem.value; + isPromise(currentValue) && (currentValue = observableFromPromise(currentValue)); + var d = new SingleAssignmentDisposable(); + subscription.setDisposable(d); + d.setDisposable(currentValue.subscribe(function(x) { + o.onNext(x); + }, self, function() { + o.onCompleted(); + })); }); - }()); - $__export("MapWrapper", MapWrapper); - Object.defineProperty(MapWrapper.clone, "parameters", {get: function() { - return [[Map]]; - }}); - Object.defineProperty(MapWrapper.createFromPairs, "parameters", {get: function() { - return [[List]]; - }}); - StringMapWrapper = (function() { - function StringMapWrapper() {} - return ($traceurRuntime.createClass)(StringMapWrapper, {}, { - create: function() { - return assert.returnType(({}), Object); - }, - contains: function(map, key) { - return map.hasOwnProperty(key); - }, - get: function(map, key) { - return map.hasOwnProperty(key) ? map[key] : undefined; - }, - set: function(map, key, value) { - map[key] = value; - }, - isEmpty: function(map) { - for (var prop in map) { - return false; - } - return true; - }, - delete: function(map, key) { - delete map[key]; - }, - forEach: function(map, callback) { - for (var prop in map) { - if (map.hasOwnProperty(prop)) { - callback(map[prop], prop); - } - } - }, - merge: function(m1, m2) { - var m = {}; - for (var attr in m1) { - if (m1.hasOwnProperty(attr)) { - m[attr] = m1[attr]; - } - } - for (var attr in m2) { - if (m2.hasOwnProperty(attr)) { - m[attr] = m2[attr]; - } + return new CompositeDisposable(subscription, cancelable, disposableCreate(function() { + isDisposed = true; + })); + }); + }; + Enumerable.prototype.catchErrorWhen = function(notificationHandler) { + var sources = this; + return new AnonymousObservable(function(o) { + var exceptions = new Subject(), + notifier = new Subject(), + handled = notificationHandler(exceptions), + notificationDisposable = handled.subscribe(notifier); + var e = sources[$iterator$](); + var isDisposed, + lastException, + subscription = new SerialDisposable(); + var cancelable = immediateScheduler.scheduleRecursive(function(self) { + if (isDisposed) { + return ; + } + try { + var currentItem = e.next(); + } catch (ex) { + return o.onError(ex); + } + if (currentItem.done) { + if (lastException) { + o.onError(lastException); + } else { + o.onCompleted(); } - return m; + return ; } + var currentValue = currentItem.value; + isPromise(currentValue) && (currentValue = observableFromPromise(currentValue)); + var outer = new SingleAssignmentDisposable(); + var inner = new SingleAssignmentDisposable(); + subscription.setDisposable(new CompositeDisposable(inner, outer)); + outer.setDisposable(currentValue.subscribe(function(x) { + o.onNext(x); + }, function(exn) { + inner.setDisposable(notifier.subscribe(self, function(ex) { + o.onError(ex); + }, function() { + o.onCompleted(); + })); + exceptions.onNext(exn); + }, function() { + o.onCompleted(); + })); }); - }()); - $__export("StringMapWrapper", StringMapWrapper); - ListWrapper = (function() { - function ListWrapper() {} - return ($traceurRuntime.createClass)(ListWrapper, {}, { - create: function() { - return assert.returnType((new List()), List); - }, - createFixedSize: function(size) { - return assert.returnType((new List(size)), List); - }, - get: function(m, k) { - return m[k]; - }, - set: function(m, k, v) { - m[k] = v; - }, - clone: function(array) { - assert.argumentTypes(array, List); - return array.slice(0); - }, - map: function(array, fn) { - return array.map(fn); - }, - forEach: function(array, fn) { - assert.argumentTypes(array, List, fn, Function); - for (var i = 0; i < array.length; i++) { - fn(array[i]); - } - }, - push: function(array, el) { - array.push(el); - }, - first: function(array) { - if (!array) - return null; - return array[0]; - }, - last: function(array) { - if (!array || array.length == 0) - return null; - return array[array.length - 1]; - }, - find: function(list, pred) { - assert.argumentTypes(list, List, pred, Function); - for (var i = 0; i < list.length; ++i) { - if (pred(list[i])) - return list[i]; - } - return null; - }, - reduce: function(list, fn, init) { - assert.argumentTypes(list, List, fn, Function, init, assert.type.any); - return list.reduce(fn, init); - }, - filter: function(array, pred) { - assert.argumentTypes(array, assert.type.any, pred, Function); - return array.filter(pred); - }, - indexOf: function(array, value) { - var startIndex = arguments[2] !== (void 0) ? arguments[2] : -1; - return array.indexOf(value, startIndex); - }, - any: function(list, pred) { - assert.argumentTypes(list, List, pred, Function); - for (var i = 0; i < list.length; ++i) { - if (pred(list[i])) - return true; + return new CompositeDisposable(notificationDisposable, subscription, cancelable, disposableCreate(function() { + isDisposed = true; + })); + }); + }; + var enumerableRepeat = Enumerable.repeat = function(value, repeatCount) { + if (repeatCount == null) { + repeatCount = -1; + } + return new Enumerable(function() { + var left = repeatCount; + return new Enumerator(function() { + if (left === 0) { + return doneEnumerator; + } + if (left > 0) { + left--; + } + return { + done: false, + value: value + }; + }); + }); + }; + var enumerableOf = Enumerable.of = function(source, selector, thisArg) { + if (selector) { + var selectorFn = bindCallback(selector, thisArg, 3); + } + return new Enumerable(function() { + var index = -1; + return new Enumerator(function() { + return ++index < source.length ? { + done: false, + value: !selector ? source[index] : selectorFn(source[index], index, source) + } : doneEnumerator; + }); + }); + }; + var Observer = Rx.Observer = function() {}; + Observer.prototype.toNotifier = function() { + var observer = this; + return function(n) { + return n.accept(observer); + }; + }; + Observer.prototype.asObserver = function() { + return new AnonymousObserver(this.onNext.bind(this), this.onError.bind(this), this.onCompleted.bind(this)); + }; + Observer.prototype.checked = function() { + return new CheckedObserver(this); + }; + var observerCreate = Observer.create = function(onNext, onError, onCompleted) { + onNext || (onNext = noop); + onError || (onError = defaultError); + onCompleted || (onCompleted = noop); + return new AnonymousObserver(onNext, onError, onCompleted); + }; + Observer.fromNotifier = function(handler, thisArg) { + return new AnonymousObserver(function(x) { + return handler.call(thisArg, notificationCreateOnNext(x)); + }, function(e) { + return handler.call(thisArg, notificationCreateOnError(e)); + }, function() { + return handler.call(thisArg, notificationCreateOnCompleted()); + }); + }; + Observer.prototype.notifyOn = function(scheduler) { + return new ObserveOnObserver(scheduler, this); + }; + Observer.prototype.makeSafe = function(disposable) { + return new AnonymousSafeObserver(this._onNext, this._onError, this._onCompleted, disposable); + }; + var AbstractObserver = Rx.internals.AbstractObserver = (function(__super__) { + inherits(AbstractObserver, __super__); + function AbstractObserver() { + this.isStopped = false; + __super__.call(this); + } + AbstractObserver.prototype.next = notImplemented; + AbstractObserver.prototype.error = notImplemented; + AbstractObserver.prototype.completed = notImplemented; + AbstractObserver.prototype.onNext = function(value) { + if (!this.isStopped) { + this.next(value); + } + }; + AbstractObserver.prototype.onError = function(error) { + if (!this.isStopped) { + this.isStopped = true; + this.error(error); + } + }; + AbstractObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + this.isStopped = true; + this.completed(); + } + }; + AbstractObserver.prototype.dispose = function() { + this.isStopped = true; + }; + AbstractObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.error(e); + return true; + } + return false; + }; + return AbstractObserver; + }(Observer)); + var AnonymousObserver = Rx.AnonymousObserver = (function(__super__) { + inherits(AnonymousObserver, __super__); + function AnonymousObserver(onNext, onError, onCompleted) { + __super__.call(this); + this._onNext = onNext; + this._onError = onError; + this._onCompleted = onCompleted; + } + AnonymousObserver.prototype.next = function(value) { + this._onNext(value); + }; + AnonymousObserver.prototype.error = function(error) { + this._onError(error); + }; + AnonymousObserver.prototype.completed = function() { + this._onCompleted(); + }; + return AnonymousObserver; + }(AbstractObserver)); + var CheckedObserver = (function(__super__) { + inherits(CheckedObserver, __super__); + function CheckedObserver(observer) { + __super__.call(this); + this._observer = observer; + this._state = 0; + } + var CheckedObserverPrototype = CheckedObserver.prototype; + CheckedObserverPrototype.onNext = function(value) { + this.checkAccess(); + var res = tryCatch(this._observer.onNext).call(this._observer, value); + this._state = 0; + res === errorObj && thrower(res.e); + }; + CheckedObserverPrototype.onError = function(err) { + this.checkAccess(); + var res = tryCatch(this._observer.onError).call(this._observer, err); + this._state = 2; + res === errorObj && thrower(res.e); + }; + CheckedObserverPrototype.onCompleted = function() { + this.checkAccess(); + var res = tryCatch(this._observer.onCompleted).call(this._observer); + this._state = 2; + res === errorObj && thrower(res.e); + }; + CheckedObserverPrototype.checkAccess = function() { + if (this._state === 1) { + throw new Error('Re-entrancy detected'); + } + if (this._state === 2) { + throw new Error('Observer completed'); + } + if (this._state === 0) { + this._state = 1; + } + }; + return CheckedObserver; + }(Observer)); + var ScheduledObserver = Rx.internals.ScheduledObserver = (function(__super__) { + inherits(ScheduledObserver, __super__); + function ScheduledObserver(scheduler, observer) { + __super__.call(this); + this.scheduler = scheduler; + this.observer = observer; + this.isAcquired = false; + this.hasFaulted = false; + this.queue = []; + this.disposable = new SerialDisposable(); + } + ScheduledObserver.prototype.next = function(value) { + var self = this; + this.queue.push(function() { + self.observer.onNext(value); + }); + }; + ScheduledObserver.prototype.error = function(e) { + var self = this; + this.queue.push(function() { + self.observer.onError(e); + }); + }; + ScheduledObserver.prototype.completed = function() { + var self = this; + this.queue.push(function() { + self.observer.onCompleted(); + }); + }; + ScheduledObserver.prototype.ensureActive = function() { + var isOwner = false, + parent = this; + if (!this.hasFaulted && this.queue.length > 0) { + isOwner = !this.isAcquired; + this.isAcquired = true; + } + if (isOwner) { + this.disposable.setDisposable(this.scheduler.scheduleRecursive(function(self) { + var work; + if (parent.queue.length > 0) { + work = parent.queue.shift(); + } else { + parent.isAcquired = false; + return ; } - return false; - }, - contains: function(list, el) { - assert.argumentTypes(list, List, el, assert.type.any); - return list.indexOf(el) !== -1; - }, - reversed: function(array) { - var a = ListWrapper.clone(array); - return a.reverse(); - }, - concat: function(a, b) { - return a.concat(b); - }, - isList: function(list) { - return Array.isArray(list); - }, - insert: function(list, index, value) { - assert.argumentTypes(list, assert.type.any, index, int, value, assert.type.any); - list.splice(index, 0, value); - }, - removeAt: function(list, index) { - assert.argumentTypes(list, assert.type.any, index, int); - var res = list[index]; - list.splice(index, 1); - return res; - }, - removeAll: function(list, items) { - for (var i = 0; i < items.length; ++i) { - var index = list.indexOf(items[i]); - list.splice(index, 1); + try { + work(); + } catch (ex) { + parent.queue = []; + parent.hasFaulted = true; + throw ex; } - }, - removeLast: function(list) { - assert.argumentTypes(list, List); - return list.pop(); - }, - remove: function(list, el) { - var index = list.indexOf(el); - if (index > -1) { - list.splice(index, 1); - return assert.returnType((true), assert.type.boolean); + self(); + })); + } + }; + ScheduledObserver.prototype.dispose = function() { + __super__.prototype.dispose.call(this); + this.disposable.dispose(); + }; + return ScheduledObserver; + }(AbstractObserver)); + var ObserveOnObserver = (function(__super__) { + inherits(ObserveOnObserver, __super__); + function ObserveOnObserver(scheduler, observer, cancel) { + __super__.call(this, scheduler, observer); + this._cancel = cancel; + } + ObserveOnObserver.prototype.next = function(value) { + __super__.prototype.next.call(this, value); + this.ensureActive(); + }; + ObserveOnObserver.prototype.error = function(e) { + __super__.prototype.error.call(this, e); + this.ensureActive(); + }; + ObserveOnObserver.prototype.completed = function() { + __super__.prototype.completed.call(this); + this.ensureActive(); + }; + ObserveOnObserver.prototype.dispose = function() { + __super__.prototype.dispose.call(this); + this._cancel && this._cancel.dispose(); + this._cancel = null; + }; + return ObserveOnObserver; + })(ScheduledObserver); + var observableProto; + var Observable = Rx.Observable = (function() { + function Observable(subscribe) { + if (Rx.config.longStackSupport && hasStacks) { + try { + throw new Error(); + } catch (e) { + this.stack = e.stack.substring(e.stack.indexOf("\n") + 1); + } + var self = this; + this._subscribe = function(observer) { + var oldOnError = observer.onError.bind(observer); + observer.onError = function(err) { + makeStackTraceLong(err, self); + oldOnError(err); + }; + return subscribe.call(self, observer); + }; + } else { + this._subscribe = subscribe; + } + } + observableProto = Observable.prototype; + observableProto.subscribe = observableProto.forEach = function(observerOrOnNext, onError, onCompleted) { + return this._subscribe(typeof observerOrOnNext === 'object' ? observerOrOnNext : observerCreate(observerOrOnNext, onError, onCompleted)); + }; + observableProto.subscribeOnNext = function(onNext, thisArg) { + return this._subscribe(observerCreate(typeof thisArg !== 'undefined' ? function(x) { + onNext.call(thisArg, x); + } : onNext)); + }; + observableProto.subscribeOnError = function(onError, thisArg) { + return this._subscribe(observerCreate(null, typeof thisArg !== 'undefined' ? function(e) { + onError.call(thisArg, e); + } : onError)); + }; + observableProto.subscribeOnCompleted = function(onCompleted, thisArg) { + return this._subscribe(observerCreate(null, null, typeof thisArg !== 'undefined' ? function() { + onCompleted.call(thisArg); + } : onCompleted)); + }; + return Observable; + })(); + var ObservableBase = Rx.ObservableBase = (function(__super__) { + inherits(ObservableBase, __super__); + function fixSubscriber(subscriber) { + return subscriber && isFunction(subscriber.dispose) ? subscriber : isFunction(subscriber) ? disposableCreate(subscriber) : disposableEmpty; + } + function setDisposable(s, state) { + var ado = state[0], + self = state[1]; + var sub = tryCatch(self.subscribeCore).call(self, ado); + if (sub === errorObj) { + if (!ado.fail(errorObj.e)) { + return thrower(errorObj.e); + } + } + ado.setDisposable(fixSubscriber(sub)); + } + function subscribe(observer) { + var ado = new AutoDetachObserver(observer), + state = [ado, this]; + if (currentThreadScheduler.scheduleRequired()) { + currentThreadScheduler.scheduleWithState(state, setDisposable); + } else { + setDisposable(null, state); + } + return ado; + } + function ObservableBase() { + __super__.call(this, subscribe); + } + ObservableBase.prototype.subscribeCore = notImplemented; + return ObservableBase; + }(Observable)); + observableProto.observeOn = function(scheduler) { + var source = this; + return new AnonymousObservable(function(observer) { + return source.subscribe(new ObserveOnObserver(scheduler, observer)); + }, source); + }; + observableProto.subscribeOn = function(scheduler) { + var source = this; + return new AnonymousObservable(function(observer) { + var m = new SingleAssignmentDisposable(), + d = new SerialDisposable(); + d.setDisposable(m); + m.setDisposable(scheduler.schedule(function() { + d.setDisposable(new ScheduledDisposable(scheduler, source.subscribe(observer))); + })); + return d; + }, source); + }; + var observableFromPromise = Observable.fromPromise = function(promise) { + return observableDefer(function() { + var subject = new Rx.AsyncSubject(); + promise.then(function(value) { + subject.onNext(value); + subject.onCompleted(); + }, subject.onError.bind(subject)); + return subject; + }); + }; + observableProto.toPromise = function(promiseCtor) { + promiseCtor || (promiseCtor = Rx.config.Promise); + if (!promiseCtor) { + throw new NotSupportedError('Promise type not provided nor in Rx.config.Promise'); + } + var source = this; + return new promiseCtor(function(resolve, reject) { + var value, + hasValue = false; + source.subscribe(function(v) { + value = v; + hasValue = true; + }, reject, function() { + hasValue && resolve(value); + }); + }); + }; + var ToArrayObservable = (function(__super__) { + inherits(ToArrayObservable, __super__); + function ToArrayObservable(source) { + this.source = source; + __super__.call(this); + } + ToArrayObservable.prototype.subscribeCore = function(observer) { + return this.source.subscribe(new ToArrayObserver(observer)); + }; + return ToArrayObservable; + }(ObservableBase)); + function ToArrayObserver(observer) { + this.observer = observer; + this.a = []; + this.isStopped = false; + } + ToArrayObserver.prototype.onNext = function(x) { + if (!this.isStopped) { + this.a.push(x); + } + }; + ToArrayObserver.prototype.onError = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onError(e); + } + }; + ToArrayObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onNext(this.a); + this.observer.onCompleted(); + } + }; + ToArrayObserver.prototype.dispose = function() { + this.isStopped = true; + }; + ToArrayObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onError(e); + return true; + } + return false; + }; + observableProto.toArray = function() { + return new ToArrayObservable(this); + }; + Observable.create = Observable.createWithDisposable = function(subscribe, parent) { + return new AnonymousObservable(subscribe, parent); + }; + var observableDefer = Observable.defer = function(observableFactory) { + return new AnonymousObservable(function(observer) { + var result; + try { + result = observableFactory(); + } catch (e) { + return observableThrow(e).subscribe(observer); + } + isPromise(result) && (result = observableFromPromise(result)); + return result.subscribe(observer); + }); + }; + var observableEmpty = Observable.empty = function(scheduler) { + isScheduler(scheduler) || (scheduler = immediateScheduler); + return new AnonymousObservable(function(observer) { + return scheduler.scheduleWithState(null, function() { + observer.onCompleted(); + }); + }); + }; + var FromObservable = (function(__super__) { + inherits(FromObservable, __super__); + function FromObservable(iterable, mapper, scheduler) { + this.iterable = iterable; + this.mapper = mapper; + this.scheduler = scheduler; + __super__.call(this); + } + FromObservable.prototype.subscribeCore = function(observer) { + var sink = new FromSink(observer, this); + return sink.run(); + }; + return FromObservable; + }(ObservableBase)); + var FromSink = (function() { + function FromSink(observer, parent) { + this.observer = observer; + this.parent = parent; + } + FromSink.prototype.run = function() { + var list = Object(this.parent.iterable), + it = getIterable(list), + observer = this.observer, + mapper = this.parent.mapper; + function loopRecursive(i, recurse) { + try { + var next = it.next(); + } catch (e) { + return observer.onError(e); + } + if (next.done) { + return observer.onCompleted(); + } + var result = next.value; + if (mapper) { + try { + result = mapper(result, i); + } catch (e) { + return observer.onError(e); } - return assert.returnType((false), assert.type.boolean); - }, - clear: function(list) { - list.splice(0, list.length); - }, - join: function(list, s) { - return list.join(s); - }, - isEmpty: function(list) { - return list.length == 0; - }, - fill: function(list, value) { - var start = arguments[2] !== (void 0) ? arguments[2] : 0; - var end = arguments[3] !== (void 0) ? arguments[3] : null; - assert.argumentTypes(list, List, value, assert.type.any, start, int, end, int); - list.fill(value, start, end === null ? undefined : end); - }, - equals: function(a, b) { - assert.argumentTypes(a, List, b, List); - if (a.length != b.length) - return assert.returnType((false), assert.type.boolean); - for (var i = 0; i < a.length; ++i) { - if (a[i] !== b[i]) - return assert.returnType((false), assert.type.boolean); + } + observer.onNext(result); + recurse(i + 1); + } + return this.parent.scheduler.scheduleRecursiveWithState(0, loopRecursive); + }; + return FromSink; + }()); + var maxSafeInteger = Math.pow(2, 53) - 1; + function StringIterable(str) { + this._s = s; + } + StringIterable.prototype[$iterator$] = function() { + return new StringIterator(this._s); + }; + function StringIterator(str) { + this._s = s; + this._l = s.length; + this._i = 0; + } + StringIterator.prototype[$iterator$] = function() { + return this; + }; + StringIterator.prototype.next = function() { + return this._i < this._l ? { + done: false, + value: this._s.charAt(this._i++) + } : doneEnumerator; + }; + function ArrayIterable(a) { + this._a = a; + } + ArrayIterable.prototype[$iterator$] = function() { + return new ArrayIterator(this._a); + }; + function ArrayIterator(a) { + this._a = a; + this._l = toLength(a); + this._i = 0; + } + ArrayIterator.prototype[$iterator$] = function() { + return this; + }; + ArrayIterator.prototype.next = function() { + return this._i < this._l ? { + done: false, + value: this._a[this._i++] + } : doneEnumerator; + }; + function numberIsFinite(value) { + return typeof value === 'number' && root.isFinite(value); + } + function isNan(n) { + return n !== n; + } + function getIterable(o) { + var i = o[$iterator$], + it; + if (!i && typeof o === 'string') { + it = new StringIterable(o); + return it[$iterator$](); + } + if (!i && o.length !== undefined) { + it = new ArrayIterable(o); + return it[$iterator$](); + } + if (!i) { + throw new TypeError('Object is not iterable'); + } + return o[$iterator$](); + } + function sign(value) { + var number = +value; + if (number === 0) { + return number; + } + if (isNaN(number)) { + return number; + } + return number < 0 ? -1 : 1; + } + function toLength(o) { + var len = +o.length; + if (isNaN(len)) { + return 0; + } + if (len === 0 || !numberIsFinite(len)) { + return len; + } + len = sign(len) * Math.floor(Math.abs(len)); + if (len <= 0) { + return 0; + } + if (len > maxSafeInteger) { + return maxSafeInteger; + } + return len; + } + var observableFrom = Observable.from = function(iterable, mapFn, thisArg, scheduler) { + if (iterable == null) { + throw new Error('iterable cannot be null.'); + } + if (mapFn && !isFunction(mapFn)) { + throw new Error('mapFn when provided must be a function'); + } + if (mapFn) { + var mapper = bindCallback(mapFn, thisArg, 2); + } + isScheduler(scheduler) || (scheduler = currentThreadScheduler); + return new FromObservable(iterable, mapper, scheduler); + }; + var FromArrayObservable = (function(__super__) { + inherits(FromArrayObservable, __super__); + function FromArrayObservable(args, scheduler) { + this.args = args; + this.scheduler = scheduler; + __super__.call(this); + } + FromArrayObservable.prototype.subscribeCore = function(observer) { + var sink = new FromArraySink(observer, this); + return sink.run(); + }; + return FromArrayObservable; + }(ObservableBase)); + function FromArraySink(observer, parent) { + this.observer = observer; + this.parent = parent; + } + FromArraySink.prototype.run = function() { + var observer = this.observer, + args = this.parent.args, + len = args.length; + function loopRecursive(i, recurse) { + if (i < len) { + observer.onNext(args[i]); + recurse(i + 1); + } else { + observer.onCompleted(); + } + } + return this.parent.scheduler.scheduleRecursiveWithState(0, loopRecursive); + }; + var observableFromArray = Observable.fromArray = function(array, scheduler) { + isScheduler(scheduler) || (scheduler = currentThreadScheduler); + return new FromArrayObservable(array, scheduler); + }; + Observable.generate = function(initialState, condition, iterate, resultSelector, scheduler) { + isScheduler(scheduler) || (scheduler = currentThreadScheduler); + return new AnonymousObservable(function(o) { + var first = true; + return scheduler.scheduleRecursiveWithState(initialState, function(state, self) { + var hasResult, + result; + try { + if (first) { + first = false; + } else { + state = iterate(state); } - return assert.returnType((true), assert.type.boolean); - }, - slice: function(l) { - var from = arguments[1] !== (void 0) ? arguments[1] : 0; - var to = arguments[2] !== (void 0) ? arguments[2] : null; - assert.argumentTypes(l, List, from, int, to, int); - return assert.returnType((l.slice(from, to === null ? undefined : to)), List); - }, - splice: function(l, from, length) { - assert.argumentTypes(l, List, from, int, length, int); - return assert.returnType((l.splice(from, length)), List); - }, - sort: function(l, compareFn) { - assert.argumentTypes(l, List, compareFn, Function); - l.sort(compareFn); + hasResult = condition(state); + hasResult && (result = resultSelector(state)); + } catch (e) { + return o.onError(e); } - }); - }()); - $__export("ListWrapper", ListWrapper); - Object.defineProperty(ListWrapper.clone, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(ListWrapper.forEach, "parameters", {get: function() { - return [[List], [Function]]; - }}); - Object.defineProperty(ListWrapper.find, "parameters", {get: function() { - return [[List], [Function]]; - }}); - Object.defineProperty(ListWrapper.reduce, "parameters", {get: function() { - return [[List], [Function], []]; - }}); - Object.defineProperty(ListWrapper.filter, "parameters", {get: function() { - return [[], [Function]]; - }}); - Object.defineProperty(ListWrapper.any, "parameters", {get: function() { - return [[List], [Function]]; - }}); - Object.defineProperty(ListWrapper.contains, "parameters", {get: function() { - return [[List], []]; - }}); - Object.defineProperty(ListWrapper.insert, "parameters", {get: function() { - return [[], [int], []]; - }}); - Object.defineProperty(ListWrapper.removeAt, "parameters", {get: function() { - return [[], [int]]; - }}); - Object.defineProperty(ListWrapper.removeLast, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(ListWrapper.fill, "parameters", {get: function() { - return [[List], [], [int], [int]]; - }}); - Object.defineProperty(ListWrapper.equals, "parameters", {get: function() { - return [[List], [List]]; - }}); - Object.defineProperty(ListWrapper.slice, "parameters", {get: function() { - return [[List], [int], [int]]; - }}); - Object.defineProperty(ListWrapper.splice, "parameters", {get: function() { - return [[List], [int], [int]]; - }}); - Object.defineProperty(ListWrapper.sort, "parameters", {get: function() { - return [[List], [Function]]; - }}); - Object.defineProperty(iterateListLike, "parameters", {get: function() { - return [[], [Function]]; - }}); - SetWrapper = (function() { - function SetWrapper() {} - return ($traceurRuntime.createClass)(SetWrapper, {}, { - createFromList: function(lst) { - assert.argumentTypes(lst, List); - return new Set(lst); - }, - has: function(s, key) { - assert.argumentTypes(s, Set, key, assert.type.any); - return assert.returnType((s.has(key)), assert.type.boolean); + if (hasResult) { + o.onNext(result); + self(state); + } else { + o.onCompleted(); } }); - }()); - $__export("SetWrapper", SetWrapper); - Object.defineProperty(SetWrapper.createFromList, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(SetWrapper.has, "parameters", {get: function() { - return [[Set], []]; - }}); - } - }; -}); - -System.register("angular2/src/di/annotations", ["angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/di/annotations"; - var CONST, - Inject, - InjectPromise, - InjectLazy, - Optional, - DependencyAnnotation, - Injectable; - return { - setters: [function($__m) { - CONST = $__m.CONST; - }], - execute: function() { - Inject = (function() { - function Inject(token) { - this.token = token; - } - return ($traceurRuntime.createClass)(Inject, {}, {}); - }()); - $__export("Inject", Inject); - Object.defineProperty(Inject, "annotations", {get: function() { - return [new CONST()]; - }}); - InjectPromise = (function() { - function InjectPromise(token) { - this.token = token; - } - return ($traceurRuntime.createClass)(InjectPromise, {}, {}); - }()); - $__export("InjectPromise", InjectPromise); - Object.defineProperty(InjectPromise, "annotations", {get: function() { - return [new CONST()]; - }}); - InjectLazy = (function() { - function InjectLazy(token) { - this.token = token; - } - return ($traceurRuntime.createClass)(InjectLazy, {}, {}); - }()); - $__export("InjectLazy", InjectLazy); - Object.defineProperty(InjectLazy, "annotations", {get: function() { - return [new CONST()]; - }}); - Optional = (function() { - function Optional() {} - return ($traceurRuntime.createClass)(Optional, {}, {}); - }()); - $__export("Optional", Optional); - Object.defineProperty(Optional, "annotations", {get: function() { - return [new CONST()]; - }}); - DependencyAnnotation = (function() { - function DependencyAnnotation() {} - return ($traceurRuntime.createClass)(DependencyAnnotation, {get token() { - return null; - }}, {}); - }()); - $__export("DependencyAnnotation", DependencyAnnotation); - Object.defineProperty(DependencyAnnotation, "annotations", {get: function() { - return [new CONST()]; - }}); - Injectable = (function() { - function Injectable() {} - return ($traceurRuntime.createClass)(Injectable, {}, {}); - }()); - $__export("Injectable", Injectable); - Object.defineProperty(Injectable, "annotations", {get: function() { - return [new CONST()]; - }}); - } - }; -}); - -System.register("angular2/src/reflection/types", [], function($__export) { - "use strict"; - var __moduleName = "angular2/src/reflection/types"; - var SetterFn, - GetterFn, - MethodFn; - return { - setters: [], - execute: function() { - SetterFn = Function; - $__export("SetterFn", SetterFn); - GetterFn = Function; - $__export("GetterFn", GetterFn); - MethodFn = Function; - $__export("MethodFn", MethodFn); + }); + }; + var observableNever = Observable.never = function() { + return new AnonymousObservable(function() { + return disposableEmpty; + }); + }; + function observableOf(scheduler, array) { + isScheduler(scheduler) || (scheduler = currentThreadScheduler); + return new FromArrayObservable(array, scheduler); } - }; -}); - -System.register("angular2/src/reflection/reflection_capabilities", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/reflection/types"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/reflection/reflection_capabilities"; - var assert, - Type, - isPresent, - List, - ListWrapper, - GetterFn, - SetterFn, - MethodFn, - ReflectionCapabilities; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Type = $__m.Type; - isPresent = $__m.isPresent; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - GetterFn = $__m.GetterFn; - SetterFn = $__m.SetterFn; - MethodFn = $__m.MethodFn; - }], - execute: function() { - ReflectionCapabilities = (function() { - function ReflectionCapabilities() {} - return ($traceurRuntime.createClass)(ReflectionCapabilities, { - factory: function(type) { - assert.argumentTypes(type, Type); - switch (type.length) { - case 0: - return assert.returnType((function() { - return new type(); - }), Function); - case 1: - return assert.returnType((function(a1) { - return new type(a1); - }), Function); - case 2: - return assert.returnType((function(a1, a2) { - return new type(a1, a2); - }), Function); - case 3: - return assert.returnType((function(a1, a2, a3) { - return new type(a1, a2, a3); - }), Function); - case 4: - return assert.returnType((function(a1, a2, a3, a4) { - return new type(a1, a2, a3, a4); - }), Function); - case 5: - return assert.returnType((function(a1, a2, a3, a4, a5) { - return new type(a1, a2, a3, a4, a5); - }), Function); - case 6: - return assert.returnType((function(a1, a2, a3, a4, a5, a6) { - return new type(a1, a2, a3, a4, a5, a6); - }), Function); - case 7: - return assert.returnType((function(a1, a2, a3, a4, a5, a6, a7) { - return new type(a1, a2, a3, a4, a5, a6, a7); - }), Function); - case 8: - return assert.returnType((function(a1, a2, a3, a4, a5, a6, a7, a8) { - return new type(a1, a2, a3, a4, a5, a6, a7, a8); - }), Function); - case 9: - return assert.returnType((function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { - return new type(a1, a2, a3, a4, a5, a6, a7, a8, a9); - }), Function); - case 10: - return assert.returnType((function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { - return new type(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); - }), Function); - } - ; - throw new Error("Factory cannot take more than 10 arguments"); - }, - parameters: function(typeOfFunc) { - if (isPresent(typeOfFunc.parameters)) { - return assert.returnType((typeOfFunc.parameters), assert.genericType(List, List)); - } - if (isPresent(window.Reflect) && isPresent(window.Reflect.getMetadata)) { - var paramtypes = window.Reflect.getMetadata('design:paramtypes', typeOfFunc); - if (isPresent(paramtypes)) { - return assert.returnType((paramtypes.map((function(p) { - return [p]; - }))), assert.genericType(List, List)); - } - } - return assert.returnType((ListWrapper.createFixedSize(typeOfFunc.length)), assert.genericType(List, List)); - }, - annotations: function(typeOfFunc) { - if (isPresent(typeOfFunc.annotations)) { - return assert.returnType((typeOfFunc.annotations), List); - } - if (isPresent(window.Reflect) && isPresent(window.Reflect.getMetadata)) { - var annotations = window.Reflect.getMetadata('annotations', typeOfFunc); - if (isPresent(annotations)) - return assert.returnType((annotations), List); - } - return assert.returnType(([]), List); - }, - getter: function(name) { - assert.argumentTypes(name, assert.type.string); - return assert.returnType((new Function('o', 'return o.' + name + ';')), GetterFn); - }, - setter: function(name) { - assert.argumentTypes(name, assert.type.string); - return assert.returnType((new Function('o', 'v', 'return o.' + name + ' = v;')), SetterFn); - }, - method: function(name) { - assert.argumentTypes(name, assert.type.string); - var method = ("o." + name); - return assert.returnType((new Function('o', 'args', ("if (!" + method + ") throw new Error('\"" + name + "\" is undefined');") + ("return " + method + ".apply(o, args);"))), MethodFn); + Observable.of = function() { + var len = arguments.length, + args = new Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; + } + return new FromArrayObservable(args, currentThreadScheduler); + }; + Observable.ofWithScheduler = function(scheduler) { + var len = arguments.length, + args = new Array(len - 1); + for (var i = 1; i < len; i++) { + args[i - 1] = arguments[i]; + } + return new FromArrayObservable(args, scheduler); + }; + Observable.pairs = function(obj, scheduler) { + scheduler || (scheduler = Rx.Scheduler.currentThread); + return new AnonymousObservable(function(observer) { + var keys = Object.keys(obj), + len = keys.length; + return scheduler.scheduleRecursiveWithState(0, function(idx, self) { + if (idx < len) { + var key = keys[idx]; + observer.onNext([key, obj[key]]); + self(idx + 1); + } else { + observer.onCompleted(); + } + }); + }); + }; + var RangeObservable = (function(__super__) { + inherits(RangeObservable, __super__); + function RangeObservable(start, count, scheduler) { + this.start = start; + this.count = count; + this.scheduler = scheduler; + __super__.call(this); + } + RangeObservable.prototype.subscribeCore = function(observer) { + var sink = new RangeSink(observer, this); + return sink.run(); + }; + return RangeObservable; + }(ObservableBase)); + var RangeSink = (function() { + function RangeSink(observer, parent) { + this.observer = observer; + this.parent = parent; + } + RangeSink.prototype.run = function() { + var start = this.parent.start, + count = this.parent.count, + observer = this.observer; + function loopRecursive(i, recurse) { + if (i < count) { + observer.onNext(start + i); + recurse(i + 1); + } else { + observer.onCompleted(); } - }, {}); - }()); - $__export("ReflectionCapabilities", ReflectionCapabilities); - Object.defineProperty(ReflectionCapabilities.prototype.factory, "parameters", {get: function() { - return [[Type]]; - }}); - Object.defineProperty(ReflectionCapabilities.prototype.getter, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(ReflectionCapabilities.prototype.setter, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(ReflectionCapabilities.prototype.method, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - } - }; -}); - -System.register("angular2/src/di/key", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/di/key"; - var assert, - MapWrapper, - stringify, - Key, - KeyRegistry, - _globalKeyRegistry; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - MapWrapper = $__m.MapWrapper; - }, function($__m) { - stringify = $__m.stringify; - }], - execute: function() { - Key = (function() { - function Key(token, id) { - this.token = token; - this.id = id; } - return ($traceurRuntime.createClass)(Key, {get displayName() { - return stringify(this.token); - }}, { - get: function(token) { - return assert.returnType((_globalKeyRegistry.get(token)), Key); - }, - get numberOfKeys() { - return _globalKeyRegistry.numberOfKeys; - } + return this.parent.scheduler.scheduleRecursiveWithState(0, loopRecursive); + }; + return RangeSink; + }()); + Observable.range = function(start, count, scheduler) { + isScheduler(scheduler) || (scheduler = currentThreadScheduler); + return new RangeObservable(start, count, scheduler); + }; + Observable.repeat = function(value, repeatCount, scheduler) { + isScheduler(scheduler) || (scheduler = currentThreadScheduler); + return observableReturn(value, scheduler).repeat(repeatCount == null ? -1 : repeatCount); + }; + var observableReturn = Observable['return'] = Observable.just = Observable.returnValue = function(value, scheduler) { + isScheduler(scheduler) || (scheduler = immediateScheduler); + return new AnonymousObservable(function(o) { + return scheduler.scheduleWithState(value, function(_, v) { + o.onNext(v); + o.onCompleted(); }); - }()); - $__export("Key", Key); - KeyRegistry = (function() { - function KeyRegistry() { - this._allKeys = MapWrapper.create(); + }); + }; + var observableThrow = Observable['throw'] = Observable.throwError = function(error, scheduler) { + isScheduler(scheduler) || (scheduler = immediateScheduler); + return new AnonymousObservable(function(observer) { + return scheduler.schedule(function() { + observer.onError(error); + }); + }); + }; + Observable.throwException = function() { + return Observable.throwError.apply(null, arguments); + }; + Observable.using = function(resourceFactory, observableFactory) { + return new AnonymousObservable(function(observer) { + var disposable = disposableEmpty, + resource, + source; + try { + resource = resourceFactory(); + resource && (disposable = resource); + source = observableFactory(resource); + } catch (exception) { + return new CompositeDisposable(observableThrow(exception).subscribe(observer), disposable); } - return ($traceurRuntime.createClass)(KeyRegistry, { - get: function(token) { - if (token instanceof Key) - return assert.returnType((token), Key); - if (MapWrapper.contains(this._allKeys, token)) { - return assert.returnType((MapWrapper.get(this._allKeys, token)), Key); - } - var newKey = new Key(token, Key.numberOfKeys); - MapWrapper.set(this._allKeys, token, newKey); - return assert.returnType((newKey), Key); - }, - get numberOfKeys() { - return MapWrapper.size(this._allKeys); + return new CompositeDisposable(source.subscribe(observer), disposable); + }); + }; + observableProto.amb = function(rightSource) { + var leftSource = this; + return new AnonymousObservable(function(observer) { + var choice, + leftChoice = 'L', + rightChoice = 'R', + leftSubscription = new SingleAssignmentDisposable(), + rightSubscription = new SingleAssignmentDisposable(); + isPromise(rightSource) && (rightSource = observableFromPromise(rightSource)); + function choiceL() { + if (!choice) { + choice = leftChoice; + rightSubscription.dispose(); + } + } + function choiceR() { + if (!choice) { + choice = rightChoice; + leftSubscription.dispose(); + } + } + leftSubscription.setDisposable(leftSource.subscribe(function(left) { + choiceL(); + if (choice === leftChoice) { + observer.onNext(left); + } + }, function(err) { + choiceL(); + if (choice === leftChoice) { + observer.onError(err); + } + }, function() { + choiceL(); + if (choice === leftChoice) { + observer.onCompleted(); + } + })); + rightSubscription.setDisposable(rightSource.subscribe(function(right) { + choiceR(); + if (choice === rightChoice) { + observer.onNext(right); + } + }, function(err) { + choiceR(); + if (choice === rightChoice) { + observer.onError(err); + } + }, function() { + choiceR(); + if (choice === rightChoice) { + observer.onCompleted(); + } + })); + return new CompositeDisposable(leftSubscription, rightSubscription); + }); + }; + Observable.amb = function() { + var acc = observableNever(), + items = []; + if (Array.isArray(arguments[0])) { + items = arguments[0]; + } else { + for (var i = 0, + len = arguments.length; i < len; i++) { + items.push(arguments[i]); + } + } + function func(previous, current) { + return previous.amb(current); + } + for (var i = 0, + len = items.length; i < len; i++) { + acc = func(acc, items[i]); + } + return acc; + }; + function observableCatchHandler(source, handler) { + return new AnonymousObservable(function(o) { + var d1 = new SingleAssignmentDisposable(), + subscription = new SerialDisposable(); + subscription.setDisposable(d1); + d1.setDisposable(source.subscribe(function(x) { + o.onNext(x); + }, function(e) { + try { + var result = handler(e); + } catch (ex) { + return o.onError(ex); + } + isPromise(result) && (result = observableFromPromise(result)); + var d = new SingleAssignmentDisposable(); + subscription.setDisposable(d); + d.setDisposable(result.subscribe(o)); + }, function(x) { + o.onCompleted(x); + })); + return subscription; + }, source); + } + observableProto['catch'] = observableProto.catchError = observableProto.catchException = function(handlerOrSecond) { + return typeof handlerOrSecond === 'function' ? observableCatchHandler(this, handlerOrSecond) : observableCatch([this, handlerOrSecond]); + }; + var observableCatch = Observable.catchError = Observable['catch'] = Observable.catchException = function() { + var items = []; + if (Array.isArray(arguments[0])) { + items = arguments[0]; + } else { + for (var i = 0, + len = arguments.length; i < len; i++) { + items.push(arguments[i]); + } + } + return enumerableOf(items).catchError(); + }; + observableProto.combineLatest = function() { + var len = arguments.length, + args = new Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; + } + if (Array.isArray(args[0])) { + args[0].unshift(this); + } else { + args.unshift(this); + } + return combineLatest.apply(this, args); + }; + var combineLatest = Observable.combineLatest = function() { + var len = arguments.length, + args = new Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; + } + var resultSelector = args.pop(); + Array.isArray(args[0]) && (args = args[0]); + return new AnonymousObservable(function(o) { + var n = args.length, + falseFactory = function() { + return false; + }, + hasValue = arrayInitialize(n, falseFactory), + hasValueAll = false, + isDone = arrayInitialize(n, falseFactory), + values = new Array(n); + function next(i) { + hasValue[i] = true; + if (hasValueAll || (hasValueAll = hasValue.every(identity))) { + try { + var res = resultSelector.apply(null, values); + } catch (e) { + return o.onError(e); + } + o.onNext(res); + } else if (isDone.filter(function(x, j) { + return j !== i; + }).every(identity)) { + o.onCompleted(); } - }, {}); - }()); - $__export("KeyRegistry", KeyRegistry); - _globalKeyRegistry = new KeyRegistry(); - } - }; -}); - -System.register("angular2/src/di/exceptions", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/di/exceptions"; - var assert, - ListWrapper, - List, - stringify, - AbstractBindingError, - NoBindingError, - AsyncBindingError, - CyclicDependencyError, - InstantiationError, - InvalidBindingError, - NoAnnotationError; - function findFirstClosedCycle(keys) { - assert.argumentTypes(keys, List); - var res = []; - for (var i = 0; i < keys.length; ++i) { - if (ListWrapper.contains(res, keys[i])) { - ListWrapper.push(res, keys[i]); - return assert.returnType((res), List); + } + function done(i) { + isDone[i] = true; + isDone.every(identity) && o.onCompleted(); + } + var subscriptions = new Array(n); + for (var idx = 0; idx < n; idx++) { + (function(i) { + var source = args[i], + sad = new SingleAssignmentDisposable(); + isPromise(source) && (source = observableFromPromise(source)); + sad.setDisposable(source.subscribe(function(x) { + values[i] = x; + next(i); + }, function(e) { + o.onError(e); + }, function() { + done(i); + })); + subscriptions[i] = sad; + }(idx)); + } + return new CompositeDisposable(subscriptions); + }, this); + }; + observableProto.concat = function() { + for (var args = [], + i = 0, + len = arguments.length; i < len; i++) { + args.push(arguments[i]); + } + args.unshift(this); + return observableConcat.apply(null, args); + }; + var observableConcat = Observable.concat = function() { + var args; + if (Array.isArray(arguments[0])) { + args = arguments[0]; } else { - ListWrapper.push(res, keys[i]); + args = new Array(arguments.length); + for (var i = 0, + len = arguments.length; i < len; i++) { + args[i] = arguments[i]; + } } - } - return assert.returnType((res), List); - } - function constructResolvingPath(keys) { - if (keys.length > 1) { - var reversed = findFirstClosedCycle(ListWrapper.reversed(keys)); - var tokenStrs = ListWrapper.map(reversed, (function(k) { - return stringify(k.token); - })); - return assert.returnType((" (" + tokenStrs.join(' -> ') + ")"), assert.type.string); - } else { - return assert.returnType((""), assert.type.string); - } - } - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - List = $__m.List; - }, function($__m) { - stringify = $__m.stringify; - }], - execute: function() { - Object.defineProperty(findFirstClosedCycle, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(constructResolvingPath, "parameters", {get: function() { - return [[List]]; - }}); - AbstractBindingError = (function($__super) { - function AbstractBindingError(key, constructResolvingMessage) { - assert.argumentTypes(key, assert.type.any, constructResolvingMessage, Function); - $traceurRuntime.superConstructor(AbstractBindingError).call(this); - this.keys = [key]; - this.constructResolvingMessage = constructResolvingMessage; - this.message = this.constructResolvingMessage(this.keys); + return enumerableOf(args).concat(); + }; + observableProto.concatAll = observableProto.concatObservable = function() { + return this.merge(1); + }; + var MergeObservable = (function(__super__) { + inherits(MergeObservable, __super__); + function MergeObservable(source, maxConcurrent) { + this.source = source; + this.maxConcurrent = maxConcurrent; + __super__.call(this); + } + MergeObservable.prototype.subscribeCore = function(observer) { + var g = new CompositeDisposable(); + g.add(this.source.subscribe(new MergeObserver(observer, this.maxConcurrent, g))); + return g; + }; + return MergeObservable; + }(ObservableBase)); + var MergeObserver = (function() { + function MergeObserver(o, max, g) { + this.o = o; + this.max = max; + this.g = g; + this.done = false; + this.q = []; + this.activeCount = 0; + this.isStopped = false; + } + MergeObserver.prototype.handleSubscribe = function(xs) { + var sad = new SingleAssignmentDisposable(); + this.g.add(sad); + isPromise(xs) && (xs = observableFromPromise(xs)); + sad.setDisposable(xs.subscribe(new InnerObserver(this, sad))); + }; + MergeObserver.prototype.onNext = function(innerSource) { + if (this.isStopped) { + return ; } - return ($traceurRuntime.createClass)(AbstractBindingError, { - addKey: function(key) { - ListWrapper.push(this.keys, key); - this.message = this.constructResolvingMessage(this.keys); - }, - toString: function() { - return assert.returnType((this.message), assert.type.string); - } - }, {}, $__super); - }(Error)); - $__export("AbstractBindingError", AbstractBindingError); - Object.defineProperty(AbstractBindingError, "parameters", {get: function() { - return [[], [Function]]; - }}); - NoBindingError = (function($__super) { - function NoBindingError(key) { - $traceurRuntime.superConstructor(NoBindingError).call(this, key, function(keys) { - assert.argumentTypes(keys, List); - var first = stringify(ListWrapper.first(keys).token); - return ("No provider for " + first + "!" + constructResolvingPath(keys)); - }); + if (this.activeCount < this.max) { + this.activeCount++; + this.handleSubscribe(innerSource); + } else { + this.q.push(innerSource); } - return ($traceurRuntime.createClass)(NoBindingError, {}, {}, $__super); - }(AbstractBindingError)); - $__export("NoBindingError", NoBindingError); - AsyncBindingError = (function($__super) { - function AsyncBindingError(key) { - $traceurRuntime.superConstructor(AsyncBindingError).call(this, key, function(keys) { - assert.argumentTypes(keys, List); - var first = stringify(ListWrapper.first(keys).token); - return ("Cannot instantiate " + first + " synchronously. ") + ("It is provided as a promise!" + constructResolvingPath(keys)); - }); + }; + MergeObserver.prototype.onError = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.o.onError(e); } - return ($traceurRuntime.createClass)(AsyncBindingError, {}, {}, $__super); - }(AbstractBindingError)); - $__export("AsyncBindingError", AsyncBindingError); - CyclicDependencyError = (function($__super) { - function CyclicDependencyError(key) { - $traceurRuntime.superConstructor(CyclicDependencyError).call(this, key, function(keys) { - assert.argumentTypes(keys, List); - return ("Cannot instantiate cyclic dependency!" + constructResolvingPath(keys)); - }); + }; + MergeObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + this.isStopped = true; + this.done = true; + this.activeCount === 0 && this.o.onCompleted(); } - return ($traceurRuntime.createClass)(CyclicDependencyError, {}, {}, $__super); - }(AbstractBindingError)); - $__export("CyclicDependencyError", CyclicDependencyError); - InstantiationError = (function($__super) { - function InstantiationError(cause, key) { - $traceurRuntime.superConstructor(InstantiationError).call(this, key, function(keys) { - assert.argumentTypes(keys, List); - var first = stringify(ListWrapper.first(keys).token); - return ("Error during instantiation of " + first + "!" + constructResolvingPath(keys) + ".") + (" ORIGINAL ERROR: " + cause); - }); - this.cause = cause; - this.causeKey = key; + }; + MergeObserver.prototype.dispose = function() { + this.isStopped = true; + }; + MergeObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.o.onError(e); + return true; + } + return false; + }; + function InnerObserver(parent, sad) { + this.parent = parent; + this.sad = sad; + this.isStopped = false; + } + InnerObserver.prototype.onNext = function(x) { + if (!this.isStopped) { + this.parent.o.onNext(x); + } + }; + InnerObserver.prototype.onError = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.parent.o.onError(e); + } + }; + InnerObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + this.isStopped = true; + var parent = this.parent; + parent.g.remove(this.sad); + if (parent.q.length > 0) { + parent.handleSubscribe(parent.q.shift()); + } else { + parent.activeCount--; + parent.done && parent.activeCount === 0 && parent.o.onCompleted(); + } + } + }; + InnerObserver.prototype.dispose = function() { + this.isStopped = true; + }; + InnerObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.parent.o.onError(e); + return true; + } + return false; + }; + return MergeObserver; + }()); + observableProto.merge = function(maxConcurrentOrOther) { + return typeof maxConcurrentOrOther !== 'number' ? observableMerge(this, maxConcurrentOrOther) : new MergeObservable(this, maxConcurrentOrOther); + }; + var observableMerge = Observable.merge = function() { + var scheduler, + sources = [], + i, + len = arguments.length; + if (!arguments[0]) { + scheduler = immediateScheduler; + for (i = 1; i < len; i++) { + sources.push(arguments[i]); } - return ($traceurRuntime.createClass)(InstantiationError, {}, {}, $__super); - }(AbstractBindingError)); - $__export("InstantiationError", InstantiationError); - InvalidBindingError = (function($__super) { - function InvalidBindingError(binding) { - $traceurRuntime.superConstructor(InvalidBindingError).call(this); - this.message = ("Invalid binding - only instances of Binding and Type are allowed, got: " + binding); + } else if (isScheduler(arguments[0])) { + scheduler = arguments[0]; + for (i = 1; i < len; i++) { + sources.push(arguments[i]); } - return ($traceurRuntime.createClass)(InvalidBindingError, {toString: function() { - return assert.returnType((this.message), assert.type.string); - }}, {}, $__super); - }(Error)); - $__export("InvalidBindingError", InvalidBindingError); - NoAnnotationError = (function($__super) { - function NoAnnotationError(typeOrFunc) { - $traceurRuntime.superConstructor(NoAnnotationError).call(this); - this.message = ("Cannot resolve all parameters for " + stringify(typeOrFunc) + ".") + " Make sure they all have valid type or annotations."; + } else { + scheduler = immediateScheduler; + for (i = 0; i < len; i++) { + sources.push(arguments[i]); } - return ($traceurRuntime.createClass)(NoAnnotationError, {toString: function() { - return assert.returnType((this.message), assert.type.string); - }}, {}, $__super); - }(Error)); - $__export("NoAnnotationError", NoAnnotationError); - } - }; -}); - -System.register("angular2/src/di/opaque_token", ["rtts_assert/rtts_assert"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/di/opaque_token"; - var assert, - OpaqueToken; - return { - setters: [function($__m) { - assert = $__m.assert; - }], - execute: function() { - OpaqueToken = (function() { - function OpaqueToken(desc) { - assert.argumentTypes(desc, assert.type.string); - this._desc = ("Token(" + desc + ")"); + } + if (Array.isArray(sources[0])) { + sources = sources[0]; + } + return observableOf(scheduler, sources).mergeAll(); + }; + var CompositeError = Rx.CompositeError = function(errors) { + this.name = "NotImplementedError"; + this.innerErrors = errors; + this.message = 'This contains multiple errors. Check the innerErrors'; + Error.call(this); + }; + CompositeError.prototype = Error.prototype; + Observable.mergeDelayError = function() { + var args; + if (Array.isArray(arguments[0])) { + args = arguments[0]; + } else { + var len = arguments.length; + args = new Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; } - return ($traceurRuntime.createClass)(OpaqueToken, {toString: function() { - return assert.returnType((this._desc), assert.type.string); - }}, {}); - }()); - $__export("OpaqueToken", OpaqueToken); - Object.defineProperty(OpaqueToken, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/parser/parser", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/parser/lexer", "angular2/src/reflection/reflection", "angular2/src/change_detection/parser/ast"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/parser/parser"; - var assert, - Injectable, - int, - isBlank, - isPresent, - BaseException, - StringWrapper, - RegExpWrapper, - ListWrapper, - List, - Lexer, - EOF, - Token, - $PERIOD, - $COLON, - $SEMICOLON, - $LBRACKET, - $RBRACKET, - $COMMA, - $LBRACE, - $RBRACE, - $LPAREN, - $RPAREN, - reflector, - Reflector, - AST, - EmptyExpr, - ImplicitReceiver, - AccessMember, - LiteralPrimitive, - Expression, - Binary, - PrefixNot, - Conditional, - Pipe, - Assignment, - Chain, - KeyedAccess, - LiteralArray, - LiteralMap, - Interpolation, - MethodCall, - FunctionCall, - TemplateBindings, - TemplateBinding, - ASTWithSource, - _implicitReceiver, - INTERPOLATION_REGEXP, - Parser, - _ParseAST; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { - int = $__m.int; - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - BaseException = $__m.BaseException; - StringWrapper = $__m.StringWrapper; - RegExpWrapper = $__m.RegExpWrapper; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - List = $__m.List; - }, function($__m) { - Lexer = $__m.Lexer; - EOF = $__m.EOF; - Token = $__m.Token; - $PERIOD = $__m.$PERIOD; - $COLON = $__m.$COLON; - $SEMICOLON = $__m.$SEMICOLON; - $LBRACKET = $__m.$LBRACKET; - $RBRACKET = $__m.$RBRACKET; - $COMMA = $__m.$COMMA; - $LBRACE = $__m.$LBRACE; - $RBRACE = $__m.$RBRACE; - $LPAREN = $__m.$LPAREN; - $RPAREN = $__m.$RPAREN; - }, function($__m) { - reflector = $__m.reflector; - Reflector = $__m.Reflector; - }, function($__m) { - AST = $__m.AST; - EmptyExpr = $__m.EmptyExpr; - ImplicitReceiver = $__m.ImplicitReceiver; - AccessMember = $__m.AccessMember; - LiteralPrimitive = $__m.LiteralPrimitive; - Expression = $__m.Expression; - Binary = $__m.Binary; - PrefixNot = $__m.PrefixNot; - Conditional = $__m.Conditional; - Pipe = $__m.Pipe; - Assignment = $__m.Assignment; - Chain = $__m.Chain; - KeyedAccess = $__m.KeyedAccess; - LiteralArray = $__m.LiteralArray; - LiteralMap = $__m.LiteralMap; - Interpolation = $__m.Interpolation; - MethodCall = $__m.MethodCall; - FunctionCall = $__m.FunctionCall; - TemplateBindings = $__m.TemplateBindings; - TemplateBinding = $__m.TemplateBinding; - ASTWithSource = $__m.ASTWithSource; - }], - execute: function() { - _implicitReceiver = new ImplicitReceiver(); - INTERPOLATION_REGEXP = RegExpWrapper.create('\\{\\{(.*?)\\}\\}'); - Parser = (function() { - function Parser(lexer) { - var providedReflector = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(lexer, Lexer, providedReflector, Reflector); - this._lexer = lexer; - this._reflector = isPresent(providedReflector) ? providedReflector : reflector; - } - return ($traceurRuntime.createClass)(Parser, { - parseAction: function(input, location) { - assert.argumentTypes(input, assert.type.string, location, assert.type.any); - var tokens = this._lexer.tokenize(input); - var ast = new _ParseAST(input, location, tokens, this._reflector, true).parseChain(); - return assert.returnType((new ASTWithSource(ast, input, location)), ASTWithSource); - }, - parseBinding: function(input, location) { - assert.argumentTypes(input, assert.type.string, location, assert.type.any); - var tokens = this._lexer.tokenize(input); - var ast = new _ParseAST(input, location, tokens, this._reflector, false).parseChain(); - return assert.returnType((new ASTWithSource(ast, input, location)), ASTWithSource); - }, - addPipes: function(bindingAst, pipes) { - if (ListWrapper.isEmpty(pipes)) - return assert.returnType((bindingAst), ASTWithSource); - var res = ListWrapper.reduce(pipes, (function(result, currentPipeName) { - return new Pipe(result, currentPipeName, [], false); - }), bindingAst.ast); - return assert.returnType((new ASTWithSource(res, bindingAst.source, bindingAst.location)), ASTWithSource); - }, - parseTemplateBindings: function(input, location) { - assert.argumentTypes(input, assert.type.string, location, assert.type.any); - var tokens = this._lexer.tokenize(input); - return assert.returnType((new _ParseAST(input, location, tokens, this._reflector, false).parseTemplateBindings()), assert.genericType(List, TemplateBinding)); - }, - parseInterpolation: function(input, location) { - assert.argumentTypes(input, assert.type.string, location, assert.type.any); - var parts = StringWrapper.split(input, INTERPOLATION_REGEXP); - if (parts.length <= 1) { - return assert.returnType((null), ASTWithSource); - } - var strings = []; - var expressions = []; - for (var i = 0; i < parts.length; i++) { - var part = parts[i]; - if (i % 2 === 0) { - ListWrapper.push(strings, part); - } else { - var tokens = this._lexer.tokenize(part); - var ast = new _ParseAST(input, location, tokens, this._reflector, false).parseChain(); - ListWrapper.push(expressions, ast); - } - } - return assert.returnType((new ASTWithSource(new Interpolation(strings, expressions), input, location)), ASTWithSource); - }, - wrapLiteralPrimitive: function(input, location) { - assert.argumentTypes(input, assert.type.string, location, assert.type.any); - return assert.returnType((new ASTWithSource(new LiteralPrimitive(input), input, location)), ASTWithSource); + } + var source = observableOf(null, args); + return new AnonymousObservable(function(o) { + var group = new CompositeDisposable(), + m = new SingleAssignmentDisposable(), + isStopped = false, + errors = []; + function setCompletion() { + if (errors.length === 0) { + o.onCompleted(); + } else if (errors.length === 1) { + o.onError(errors[0]); + } else { + o.onError(new CompositeError(errors)); } - }, {}); - }()); - $__export("Parser", Parser); - Object.defineProperty(Parser, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(Parser, "parameters", {get: function() { - return [[Lexer], [Reflector]]; - }}); - Object.defineProperty(Parser.prototype.parseAction, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(Parser.prototype.parseBinding, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(Parser.prototype.addPipes, "parameters", {get: function() { - return [[ASTWithSource], [assert.genericType(List, String)]]; - }}); - Object.defineProperty(Parser.prototype.parseTemplateBindings, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(Parser.prototype.parseInterpolation, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(Parser.prototype.wrapLiteralPrimitive, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any]]; - }}); - _ParseAST = (function() { - function _ParseAST(input, location, tokens, reflector, parseAction) { - assert.argumentTypes(input, assert.type.string, location, assert.type.any, tokens, List, reflector, Reflector, parseAction, assert.type.boolean); - this.input = input; - this.location = location; - this.tokens = tokens; - this.index = 0; - this.reflector = reflector; - this.parseAction = parseAction; } - return ($traceurRuntime.createClass)(_ParseAST, { - peek: function(offset) { - assert.argumentTypes(offset, int); - var i = this.index + offset; - return assert.returnType((i < this.tokens.length ? this.tokens[i] : EOF), Token); - }, - get next() { - return assert.returnType((this.peek(0)), Token); - }, - get inputIndex() { - return assert.returnType(((this.index < this.tokens.length) ? this.next.index : this.input.length), int); - }, - advance: function() { - this.index++; - }, - optionalCharacter: function(code) { - assert.argumentTypes(code, int); - if (this.next.isCharacter(code)) { - this.advance(); - return assert.returnType((true), assert.type.boolean); - } else { - return assert.returnType((false), assert.type.boolean); - } - }, - optionalKeywordVar: function() { - if (this.peekKeywordVar()) { - this.advance(); - return assert.returnType((true), assert.type.boolean); - } else { - return assert.returnType((false), assert.type.boolean); - } - }, - peekKeywordVar: function() { - return assert.returnType((this.next.isKeywordVar() || this.next.isOperator('#')), assert.type.boolean); - }, - expectCharacter: function(code) { - assert.argumentTypes(code, int); - if (this.optionalCharacter(code)) - return ; - this.error(("Missing expected " + StringWrapper.fromCharCode(code))); - }, - optionalOperator: function(op) { - assert.argumentTypes(op, assert.type.string); - if (this.next.isOperator(op)) { - this.advance(); - return assert.returnType((true), assert.type.boolean); - } else { - return assert.returnType((false), assert.type.boolean); - } - }, - expectOperator: function(operator) { - assert.argumentTypes(operator, assert.type.string); - if (this.optionalOperator(operator)) - return ; - this.error(("Missing expected operator " + operator)); - }, - expectIdentifierOrKeyword: function() { - var n = this.next; - if (!n.isIdentifier() && !n.isKeyword()) { - this.error(("Unexpected token " + n + ", expected identifier or keyword")); - } - this.advance(); - return assert.returnType((n.toString()), assert.type.string); - }, - expectIdentifierOrKeywordOrString: function() { - var n = this.next; - if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) { - this.error(("Unexpected token " + n + ", expected identifier, keyword, or string")); - } - this.advance(); - return assert.returnType((n.toString()), assert.type.string); - }, - parseChain: function() { - var exprs = []; - while (this.index < this.tokens.length) { - var expr = this.parsePipe(); - ListWrapper.push(exprs, expr); - if (this.optionalCharacter($SEMICOLON)) { - if (!this.parseAction) { - this.error("Binding expression cannot contain chained expression"); - } - while (this.optionalCharacter($SEMICOLON)) {} - } else if (this.index < this.tokens.length) { - this.error(("Unexpected token '" + this.next + "'")); - } - } - if (exprs.length == 0) - return assert.returnType((new EmptyExpr()), AST); - if (exprs.length == 1) - return assert.returnType((exprs[0]), AST); - return assert.returnType((new Chain(exprs)), AST); - }, - parsePipe: function() { - var result = this.parseExpression(); - if (this.optionalOperator("|")) { - return this.parseInlinedPipe(result); - } else { - return result; - } - }, - parseExpression: function() { - var start = this.inputIndex; - var result = this.parseConditional(); - while (this.next.isOperator('=')) { - if (!result.isAssignable) { - var end = this.inputIndex; - var expression = this.input.substring(start, end); - this.error(("Expression " + expression + " is not assignable")); - } - if (!this.parseAction) { - this.error("Binding expression cannot contain assignments"); - } - this.expectOperator('='); - result = new Assignment(result, this.parseConditional()); - } - return result; - }, - parseConditional: function() { - var start = this.inputIndex; - var result = this.parseLogicalOr(); - if (this.optionalOperator('?')) { - var yes = this.parseExpression(); - if (!this.optionalCharacter($COLON)) { - var end = this.inputIndex; - var expression = this.input.substring(start, end); - this.error(("Conditional expression " + expression + " requires all 3 expressions")); - } - var no = this.parseExpression(); - return new Conditional(result, yes, no); - } else { - return result; - } - }, - parseLogicalOr: function() { - var result = this.parseLogicalAnd(); - while (this.optionalOperator('||')) { - result = new Binary('||', result, this.parseLogicalAnd()); - } - return result; - }, - parseLogicalAnd: function() { - var result = this.parseEquality(); - while (this.optionalOperator('&&')) { - result = new Binary('&&', result, this.parseEquality()); - } - return result; - }, - parseEquality: function() { - var result = this.parseRelational(); - while (true) { - if (this.optionalOperator('==')) { - result = new Binary('==', result, this.parseRelational()); - } else if (this.optionalOperator('===')) { - result = new Binary('===', result, this.parseRelational()); - } else if (this.optionalOperator('!=')) { - result = new Binary('!=', result, this.parseRelational()); - } else if (this.optionalOperator('!==')) { - result = new Binary('!==', result, this.parseRelational()); - } else { - return result; - } - } - }, - parseRelational: function() { - var result = this.parseAdditive(); - while (true) { - if (this.optionalOperator('<')) { - result = new Binary('<', result, this.parseAdditive()); - } else if (this.optionalOperator('>')) { - result = new Binary('>', result, this.parseAdditive()); - } else if (this.optionalOperator('<=')) { - result = new Binary('<=', result, this.parseAdditive()); - } else if (this.optionalOperator('>=')) { - result = new Binary('>=', result, this.parseAdditive()); - } else { - return result; - } - } - }, - parseAdditive: function() { - var result = this.parseMultiplicative(); - while (true) { - if (this.optionalOperator('+')) { - result = new Binary('+', result, this.parseMultiplicative()); - } else if (this.optionalOperator('-')) { - result = new Binary('-', result, this.parseMultiplicative()); - } else { - return result; - } - } - }, - parseMultiplicative: function() { - var result = this.parsePrefix(); - while (true) { - if (this.optionalOperator('*')) { - result = new Binary('*', result, this.parsePrefix()); - } else if (this.optionalOperator('%')) { - result = new Binary('%', result, this.parsePrefix()); - } else if (this.optionalOperator('/')) { - result = new Binary('/', result, this.parsePrefix()); - } else { - return result; - } - } - }, - parsePrefix: function() { - if (this.optionalOperator('+')) { - return this.parsePrefix(); - } else if (this.optionalOperator('-')) { - return new Binary('-', new LiteralPrimitive(0), this.parsePrefix()); - } else if (this.optionalOperator('!')) { - return new PrefixNot(this.parsePrefix()); - } else { - return this.parseCallChain(); - } - }, - parseCallChain: function() { - var result = this.parsePrimary(); - while (true) { - if (this.optionalCharacter($PERIOD)) { - result = this.parseAccessMemberOrMethodCall(result); - } else if (this.optionalCharacter($LBRACKET)) { - var key = this.parseExpression(); - this.expectCharacter($RBRACKET); - result = new KeyedAccess(result, key); - } else if (this.optionalCharacter($LPAREN)) { - var args = this.parseCallArguments(); - this.expectCharacter($RPAREN); - result = new FunctionCall(result, args); + group.add(m); + m.setDisposable(source.subscribe(function(innerSource) { + var innerSubscription = new SingleAssignmentDisposable(); + group.add(innerSubscription); + isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); + innerSubscription.setDisposable(innerSource.subscribe(function(x) { + o.onNext(x); + }, function(e) { + errors.push(e); + group.remove(innerSubscription); + isStopped && group.length === 1 && setCompletion(); + }, function() { + group.remove(innerSubscription); + isStopped && group.length === 1 && setCompletion(); + })); + }, function(e) { + errors.push(e); + isStopped = true; + group.length === 1 && setCompletion(); + }, function() { + isStopped = true; + group.length === 1 && setCompletion(); + })); + return group; + }); + }; + var MergeAllObservable = (function(__super__) { + inherits(MergeAllObservable, __super__); + function MergeAllObservable(source) { + this.source = source; + __super__.call(this); + } + MergeAllObservable.prototype.subscribeCore = function(observer) { + var g = new CompositeDisposable(), + m = new SingleAssignmentDisposable(); + g.add(m); + m.setDisposable(this.source.subscribe(new MergeAllObserver(observer, g))); + return g; + }; + return MergeAllObservable; + }(ObservableBase)); + var MergeAllObserver = (function() { + function MergeAllObserver(o, g) { + this.o = o; + this.g = g; + this.isStopped = false; + this.done = false; + } + MergeAllObserver.prototype.onNext = function(innerSource) { + if (this.isStopped) { + return ; + } + var sad = new SingleAssignmentDisposable(); + this.g.add(sad); + isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); + sad.setDisposable(innerSource.subscribe(new InnerObserver(this, this.g, sad))); + }; + MergeAllObserver.prototype.onError = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.o.onError(e); + } + }; + MergeAllObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + this.isStopped = true; + this.done = true; + this.g.length === 1 && this.o.onCompleted(); + } + }; + MergeAllObserver.prototype.dispose = function() { + this.isStopped = true; + }; + MergeAllObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.o.onError(e); + return true; + } + return false; + }; + function InnerObserver(parent, g, sad) { + this.parent = parent; + this.g = g; + this.sad = sad; + this.isStopped = false; + } + InnerObserver.prototype.onNext = function(x) { + if (!this.isStopped) { + this.parent.o.onNext(x); + } + }; + InnerObserver.prototype.onError = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.parent.o.onError(e); + } + }; + InnerObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + var parent = this.parent; + this.isStopped = true; + parent.g.remove(this.sad); + parent.done && parent.g.length === 1 && parent.o.onCompleted(); + } + }; + InnerObserver.prototype.dispose = function() { + this.isStopped = true; + }; + InnerObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.parent.o.onError(e); + return true; + } + return false; + }; + return MergeAllObserver; + }()); + observableProto.mergeAll = observableProto.mergeObservable = function() { + return new MergeAllObservable(this); + }; + observableProto.onErrorResumeNext = function(second) { + if (!second) { + throw new Error('Second observable is required'); + } + return onErrorResumeNext([this, second]); + }; + var onErrorResumeNext = Observable.onErrorResumeNext = function() { + var sources = []; + if (Array.isArray(arguments[0])) { + sources = arguments[0]; + } else { + for (var i = 0, + len = arguments.length; i < len; i++) { + sources.push(arguments[i]); + } + } + return new AnonymousObservable(function(observer) { + var pos = 0, + subscription = new SerialDisposable(), + cancelable = immediateScheduler.scheduleRecursive(function(self) { + var current, + d; + if (pos < sources.length) { + current = sources[pos++]; + isPromise(current) && (current = observableFromPromise(current)); + d = new SingleAssignmentDisposable(); + subscription.setDisposable(d); + d.setDisposable(current.subscribe(observer.onNext.bind(observer), self, self)); } else { - return assert.returnType((result), AST); + observer.onCompleted(); } + }); + return new CompositeDisposable(subscription, cancelable); + }); + }; + observableProto.skipUntil = function(other) { + var source = this; + return new AnonymousObservable(function(o) { + var isOpen = false; + var disposables = new CompositeDisposable(source.subscribe(function(left) { + isOpen && o.onNext(left); + }, function(e) { + o.onError(e); + }, function() { + isOpen && o.onCompleted(); + })); + isPromise(other) && (other = observableFromPromise(other)); + var rightSubscription = new SingleAssignmentDisposable(); + disposables.add(rightSubscription); + rightSubscription.setDisposable(other.subscribe(function() { + isOpen = true; + rightSubscription.dispose(); + }, function(e) { + o.onError(e); + }, function() { + rightSubscription.dispose(); + })); + return disposables; + }, source); + }; + observableProto['switch'] = observableProto.switchLatest = function() { + var sources = this; + return new AnonymousObservable(function(observer) { + var hasLatest = false, + innerSubscription = new SerialDisposable(), + isStopped = false, + latest = 0, + subscription = sources.subscribe(function(innerSource) { + var d = new SingleAssignmentDisposable(), + id = ++latest; + hasLatest = true; + innerSubscription.setDisposable(d); + isPromise(innerSource) && (innerSource = observableFromPromise(innerSource)); + d.setDisposable(innerSource.subscribe(function(x) { + latest === id && observer.onNext(x); + }, function(e) { + latest === id && observer.onError(e); + }, function() { + if (latest === id) { + hasLatest = false; + isStopped && observer.onCompleted(); + } + })); + }, function(e) { + observer.onError(e); + }, function() { + isStopped = true; + !hasLatest && observer.onCompleted(); + }); + return new CompositeDisposable(subscription, innerSubscription); + }, sources); + }; + observableProto.takeUntil = function(other) { + var source = this; + return new AnonymousObservable(function(o) { + isPromise(other) && (other = observableFromPromise(other)); + return new CompositeDisposable(source.subscribe(o), other.subscribe(function() { + o.onCompleted(); + }, function(e) { + o.onError(e); + }, noop)); + }, source); + }; + observableProto.withLatestFrom = function() { + var len = arguments.length, + args = new Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; + } + var resultSelector = args.pop(), + source = this; + if (typeof source === 'undefined') { + throw new Error('Source observable not found for withLatestFrom().'); + } + if (typeof resultSelector !== 'function') { + throw new Error('withLatestFrom() expects a resultSelector function.'); + } + if (Array.isArray(args[0])) { + args = args[0]; + } + return new AnonymousObservable(function(observer) { + var falseFactory = function() { + return false; + }, + n = args.length, + hasValue = arrayInitialize(n, falseFactory), + hasValueAll = false, + values = new Array(n); + var subscriptions = new Array(n + 1); + for (var idx = 0; idx < n; idx++) { + (function(i) { + var other = args[i], + sad = new SingleAssignmentDisposable(); + isPromise(other) && (other = observableFromPromise(other)); + sad.setDisposable(other.subscribe(function(x) { + values[i] = x; + hasValue[i] = true; + hasValueAll = hasValue.every(identity); + }, observer.onError.bind(observer), function() {})); + subscriptions[i] = sad; + }(idx)); + } + var sad = new SingleAssignmentDisposable(); + sad.setDisposable(source.subscribe(function(x) { + var res; + var allValues = [x].concat(values); + if (!hasValueAll) + return ; + try { + res = resultSelector.apply(null, allValues); + } catch (ex) { + observer.onError(ex); + return ; + } + observer.onNext(res); + }, observer.onError.bind(observer), function() { + observer.onCompleted(); + })); + subscriptions[n] = sad; + return new CompositeDisposable(subscriptions); + }, this); + }; + function zipArray(second, resultSelector) { + var first = this; + return new AnonymousObservable(function(observer) { + var index = 0, + len = second.length; + return first.subscribe(function(left) { + if (index < len) { + var right = second[index++], + result; + try { + result = resultSelector(left, right); + } catch (e) { + return observer.onError(e); } - }, - parsePrimary: function() { - if (this.optionalCharacter($LPAREN)) { - var result = this.parsePipe(); - this.expectCharacter($RPAREN); - return result; - } else if (this.next.isKeywordNull() || this.next.isKeywordUndefined()) { - this.advance(); - return new LiteralPrimitive(null); - } else if (this.next.isKeywordTrue()) { - this.advance(); - return new LiteralPrimitive(true); - } else if (this.next.isKeywordFalse()) { - this.advance(); - return new LiteralPrimitive(false); - } else if (this.optionalCharacter($LBRACKET)) { - var elements = this.parseExpressionList($RBRACKET); - this.expectCharacter($RBRACKET); - return new LiteralArray(elements); - } else if (this.next.isCharacter($LBRACE)) { - return this.parseLiteralMap(); - } else if (this.next.isIdentifier()) { - return this.parseAccessMemberOrMethodCall(_implicitReceiver); - } else if (this.next.isNumber()) { - var value = this.next.toNumber(); - this.advance(); - return new LiteralPrimitive(value); - } else if (this.next.isString()) { - var value = this.next.toString(); - this.advance(); - return new LiteralPrimitive(value); - } else if (this.index >= this.tokens.length) { - this.error(("Unexpected end of expression: " + this.input)); - } else { - this.error(("Unexpected token " + this.next)); - } - }, - parseExpressionList: function(terminator) { - assert.argumentTypes(terminator, int); - var result = []; - if (!this.next.isCharacter(terminator)) { - do { - ListWrapper.push(result, this.parseExpression()); - } while (this.optionalCharacter($COMMA)); + observer.onNext(result); + } else { + observer.onCompleted(); + } + }, function(e) { + observer.onError(e); + }, function() { + observer.onCompleted(); + }); + }, first); + } + function falseFactory() { + return false; + } + function emptyArrayFactory() { + return []; + } + observableProto.zip = function() { + if (Array.isArray(arguments[0])) { + return zipArray.apply(this, arguments); + } + var len = arguments.length, + args = new Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; + } + var parent = this, + resultSelector = args.pop(); + args.unshift(parent); + return new AnonymousObservable(function(observer) { + var n = args.length, + queues = arrayInitialize(n, emptyArrayFactory), + isDone = arrayInitialize(n, falseFactory); + function next(i) { + var res, + queuedValues; + if (queues.every(function(x) { + return x.length > 0; + })) { + try { + queuedValues = queues.map(function(x) { + return x.shift(); + }); + res = resultSelector.apply(parent, queuedValues); + } catch (ex) { + observer.onError(ex); + return ; } - return assert.returnType((result), List); - }, - parseLiteralMap: function() { - var keys = []; - var values = []; - this.expectCharacter($LBRACE); - if (!this.optionalCharacter($RBRACE)) { - do { - var key = this.expectIdentifierOrKeywordOrString(); - ListWrapper.push(keys, key); - this.expectCharacter($COLON); - ListWrapper.push(values, this.parseExpression()); - } while (this.optionalCharacter($COMMA)); - this.expectCharacter($RBRACE); + observer.onNext(res); + } else if (isDone.filter(function(x, j) { + return j !== i; + }).every(identity)) { + observer.onCompleted(); + } + } + ; + function done(i) { + isDone[i] = true; + if (isDone.every(function(x) { + return x; + })) { + observer.onCompleted(); + } + } + var subscriptions = new Array(n); + for (var idx = 0; idx < n; idx++) { + (function(i) { + var source = args[i], + sad = new SingleAssignmentDisposable(); + isPromise(source) && (source = observableFromPromise(source)); + sad.setDisposable(source.subscribe(function(x) { + queues[i].push(x); + next(i); + }, function(e) { + observer.onError(e); + }, function() { + done(i); + })); + subscriptions[i] = sad; + })(idx); + } + return new CompositeDisposable(subscriptions); + }, parent); + }; + Observable.zip = function() { + var len = arguments.length, + args = new Array(len); + for (var i = 0; i < len; i++) { + args[i] = arguments[i]; + } + var first = args.shift(); + return first.zip.apply(first, args); + }; + Observable.zipArray = function() { + var sources; + if (Array.isArray(arguments[0])) { + sources = arguments[0]; + } else { + var len = arguments.length; + sources = new Array(len); + for (var i = 0; i < len; i++) { + sources[i] = arguments[i]; + } + } + return new AnonymousObservable(function(observer) { + var n = sources.length, + queues = arrayInitialize(n, function() { + return []; + }), + isDone = arrayInitialize(n, function() { + return false; + }); + function next(i) { + if (queues.every(function(x) { + return x.length > 0; + })) { + var res = queues.map(function(x) { + return x.shift(); + }); + observer.onNext(res); + } else if (isDone.filter(function(x, j) { + return j !== i; + }).every(identity)) { + observer.onCompleted(); + return ; + } + } + ; + function done(i) { + isDone[i] = true; + if (isDone.every(identity)) { + observer.onCompleted(); + return ; + } + } + var subscriptions = new Array(n); + for (var idx = 0; idx < n; idx++) { + (function(i) { + subscriptions[i] = new SingleAssignmentDisposable(); + subscriptions[i].setDisposable(sources[i].subscribe(function(x) { + queues[i].push(x); + next(i); + }, function(e) { + observer.onError(e); + }, function() { + done(i); + })); + })(idx); + } + return new CompositeDisposable(subscriptions); + }); + }; + observableProto.asObservable = function() { + var source = this; + return new AnonymousObservable(function(o) { + return source.subscribe(o); + }, this); + }; + observableProto.bufferWithCount = function(count, skip) { + if (typeof skip !== 'number') { + skip = count; + } + return this.windowWithCount(count, skip).selectMany(function(x) { + return x.toArray(); + }).where(function(x) { + return x.length > 0; + }); + }; + observableProto.dematerialize = function() { + var source = this; + return new AnonymousObservable(function(o) { + return source.subscribe(function(x) { + return x.accept(o); + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, this); + }; + observableProto.distinctUntilChanged = function(keySelector, comparer) { + var source = this; + comparer || (comparer = defaultComparer); + return new AnonymousObservable(function(o) { + var hasCurrentKey = false, + currentKey; + return source.subscribe(function(value) { + var key = value; + if (keySelector) { + try { + key = keySelector(value); + } catch (e) { + o.onError(e); + return ; } - return new LiteralMap(keys, values); - }, - parseAccessMemberOrMethodCall: function(receiver) { - var id = this.expectIdentifierOrKeyword(); - if (this.optionalCharacter($LPAREN)) { - var args = this.parseCallArguments(); - this.expectCharacter($RPAREN); - var fn = this.reflector.method(id); - return assert.returnType((new MethodCall(receiver, id, fn, args)), AST); + } + if (hasCurrentKey) { + try { + var comparerEquals = comparer(currentKey, key); + } catch (e) { + o.onError(e); + return ; + } + } + if (!hasCurrentKey || !comparerEquals) { + hasCurrentKey = true; + currentKey = key; + o.onNext(value); + } + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, this); + }; + observableProto['do'] = observableProto.tap = observableProto.doAction = function(observerOrOnNext, onError, onCompleted) { + var source = this; + return new AnonymousObservable(function(observer) { + var tapObserver = !observerOrOnNext || isFunction(observerOrOnNext) ? observerCreate(observerOrOnNext || noop, onError || noop, onCompleted || noop) : observerOrOnNext; + return source.subscribe(function(x) { + try { + tapObserver.onNext(x); + } catch (e) { + observer.onError(e); + } + observer.onNext(x); + }, function(err) { + try { + tapObserver.onError(err); + } catch (e) { + observer.onError(e); + } + observer.onError(err); + }, function() { + try { + tapObserver.onCompleted(); + } catch (e) { + observer.onError(e); + } + observer.onCompleted(); + }); + }, this); + }; + observableProto.doOnNext = observableProto.tapOnNext = function(onNext, thisArg) { + return this.tap(typeof thisArg !== 'undefined' ? function(x) { + onNext.call(thisArg, x); + } : onNext); + }; + observableProto.doOnError = observableProto.tapOnError = function(onError, thisArg) { + return this.tap(noop, typeof thisArg !== 'undefined' ? function(e) { + onError.call(thisArg, e); + } : onError); + }; + observableProto.doOnCompleted = observableProto.tapOnCompleted = function(onCompleted, thisArg) { + return this.tap(noop, null, typeof thisArg !== 'undefined' ? function() { + onCompleted.call(thisArg); + } : onCompleted); + }; + observableProto['finally'] = observableProto.ensure = function(action) { + var source = this; + return new AnonymousObservable(function(observer) { + var subscription; + try { + subscription = source.subscribe(observer); + } catch (e) { + action(); + throw e; + } + return disposableCreate(function() { + try { + subscription.dispose(); + } catch (e) { + throw e; + } finally { + action(); + } + }); + }, this); + }; + observableProto.finallyAction = function(action) { + return this.ensure(action); + }; + observableProto.ignoreElements = function() { + var source = this; + return new AnonymousObservable(function(o) { + return source.subscribe(noop, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, source); + }; + observableProto.materialize = function() { + var source = this; + return new AnonymousObservable(function(observer) { + return source.subscribe(function(value) { + observer.onNext(notificationCreateOnNext(value)); + }, function(e) { + observer.onNext(notificationCreateOnError(e)); + observer.onCompleted(); + }, function() { + observer.onNext(notificationCreateOnCompleted()); + observer.onCompleted(); + }); + }, source); + }; + observableProto.repeat = function(repeatCount) { + return enumerableRepeat(this, repeatCount).concat(); + }; + observableProto.retry = function(retryCount) { + return enumerableRepeat(this, retryCount).catchError(); + }; + observableProto.retryWhen = function(notifier) { + return enumerableRepeat(this).catchErrorWhen(notifier); + }; + observableProto.scan = function() { + var hasSeed = false, + seed, + accumulator, + source = this; + if (arguments.length === 2) { + hasSeed = true; + seed = arguments[0]; + accumulator = arguments[1]; + } else { + accumulator = arguments[0]; + } + return new AnonymousObservable(function(o) { + var hasAccumulation, + accumulation, + hasValue; + return source.subscribe(function(x) { + !hasValue && (hasValue = true); + try { + if (hasAccumulation) { + accumulation = accumulator(accumulation, x); } else { - var getter = this.reflector.getter(id); - var setter = this.reflector.setter(id); - var am = new AccessMember(receiver, id, getter, setter); - if (this.optionalOperator("|")) { - return assert.returnType((this.parseInlinedPipe(am)), AST); - } else { - return assert.returnType((am), AST); - } + accumulation = hasSeed ? accumulator(seed, x) : x; + hasAccumulation = true; } - }, - parseInlinedPipe: function(result) { - do { - if (this.parseAction) { - this.error("Cannot have a pipe in an action expression"); - } - var name = this.expectIdentifierOrKeyword(); - var args = ListWrapper.create(); - while (this.optionalCharacter($COLON)) { - ListWrapper.push(args, this.parseExpression()); - } - result = new Pipe(result, name, args, true); - } while (this.optionalOperator("|")); - return result; - }, - parseCallArguments: function() { - if (this.next.isCharacter($RPAREN)) - return []; - var positionals = []; - do { - ListWrapper.push(positionals, this.parseExpression()); - } while (this.optionalCharacter($COMMA)); - return positionals; - }, - expectTemplateBindingKey: function() { - var result = ''; - var operatorFound = false; - do { - result += this.expectIdentifierOrKeywordOrString(); - operatorFound = this.optionalOperator('-'); - if (operatorFound) { - result += '-'; - } - } while (operatorFound); - return result.toString(); - }, - parseTemplateBindings: function() { - var bindings = []; - while (this.index < this.tokens.length) { - var keyIsVar = assert.type(this.optionalKeywordVar(), assert.type.boolean); - var key = this.expectTemplateBindingKey(); - this.optionalCharacter($COLON); - var name = null; - var expression = null; - if (this.next !== EOF) { - if (keyIsVar) { - if (this.optionalOperator("=")) { - name = this.expectTemplateBindingKey(); - } else { - name = '\$implicit'; - } - } else if (!this.peekKeywordVar()) { - var start = this.inputIndex; - var ast = this.parsePipe(); - var source = this.input.substring(start, this.inputIndex); - expression = new ASTWithSource(ast, source, this.location); - } - } - ListWrapper.push(bindings, new TemplateBinding(key, keyIsVar, name, expression)); - if (!this.optionalCharacter($SEMICOLON)) { - this.optionalCharacter($COMMA); - } + } catch (e) { + o.onError(e); + return ; + } + o.onNext(accumulation); + }, function(e) { + o.onError(e); + }, function() { + !hasValue && hasSeed && o.onNext(seed); + o.onCompleted(); + }); + }, source); + }; + observableProto.skipLast = function(count) { + if (count < 0) { + throw new ArgumentOutOfRangeError(); + } + var source = this; + return new AnonymousObservable(function(o) { + var q = []; + return source.subscribe(function(x) { + q.push(x); + q.length > count && o.onNext(q.shift()); + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, source); + }; + observableProto.startWith = function() { + var values, + scheduler, + start = 0; + if (!!arguments.length && isScheduler(arguments[0])) { + scheduler = arguments[0]; + start = 1; + } else { + scheduler = immediateScheduler; + } + for (var args = [], + i = start, + len = arguments.length; i < len; i++) { + args.push(arguments[i]); + } + return enumerableOf([observableFromArray(args, scheduler), this]).concat(); + }; + observableProto.takeLast = function(count) { + if (count < 0) { + throw new ArgumentOutOfRangeError(); + } + var source = this; + return new AnonymousObservable(function(o) { + var q = []; + return source.subscribe(function(x) { + q.push(x); + q.length > count && q.shift(); + }, function(e) { + o.onError(e); + }, function() { + while (q.length > 0) { + o.onNext(q.shift()); + } + o.onCompleted(); + }); + }, source); + }; + observableProto.takeLastBuffer = function(count) { + var source = this; + return new AnonymousObservable(function(o) { + var q = []; + return source.subscribe(function(x) { + q.push(x); + q.length > count && q.shift(); + }, function(e) { + o.onError(e); + }, function() { + o.onNext(q); + o.onCompleted(); + }); + }, source); + }; + observableProto.windowWithCount = function(count, skip) { + var source = this; + +count || (count = 0); + Math.abs(count) === Infinity && (count = 0); + if (count <= 0) { + throw new ArgumentOutOfRangeError(); + } + skip == null && (skip = count); + +skip || (skip = 0); + Math.abs(skip) === Infinity && (skip = 0); + if (skip <= 0) { + throw new ArgumentOutOfRangeError(); + } + return new AnonymousObservable(function(observer) { + var m = new SingleAssignmentDisposable(), + refCountDisposable = new RefCountDisposable(m), + n = 0, + q = []; + function createWindow() { + var s = new Subject(); + q.push(s); + observer.onNext(addRef(s, refCountDisposable)); + } + createWindow(); + m.setDisposable(source.subscribe(function(x) { + for (var i = 0, + len = q.length; i < len; i++) { + q[i].onNext(x); + } + var c = n - count + 1; + c >= 0 && c % skip === 0 && q.shift().onCompleted(); + ++n % skip === 0 && createWindow(); + }, function(e) { + while (q.length > 0) { + q.shift().onError(e); + } + observer.onError(e); + }, function() { + while (q.length > 0) { + q.shift().onCompleted(); + } + observer.onCompleted(); + })); + return refCountDisposable; + }, source); + }; + function concatMap(source, selector, thisArg) { + var selectorFunc = bindCallback(selector, thisArg, 3); + return source.map(function(x, i) { + var result = selectorFunc(x, i, source); + isPromise(result) && (result = observableFromPromise(result)); + (isArrayLike(result) || isIterable(result)) && (result = observableFrom(result)); + return result; + }).concatAll(); + } + observableProto.selectConcat = observableProto.concatMap = function(selector, resultSelector, thisArg) { + if (isFunction(selector) && isFunction(resultSelector)) { + return this.concatMap(function(x, i) { + var selectorResult = selector(x, i); + isPromise(selectorResult) && (selectorResult = observableFromPromise(selectorResult)); + (isArrayLike(selectorResult) || isIterable(selectorResult)) && (selectorResult = observableFrom(selectorResult)); + return selectorResult.map(function(y, i2) { + return resultSelector(x, y, i, i2); + }); + }); + } + return isFunction(selector) ? concatMap(this, selector, thisArg) : concatMap(this, function() { + return selector; + }); + }; + observableProto.concatMapObserver = observableProto.selectConcatObserver = function(onNext, onError, onCompleted, thisArg) { + var source = this, + onNextFunc = bindCallback(onNext, thisArg, 2), + onErrorFunc = bindCallback(onError, thisArg, 1), + onCompletedFunc = bindCallback(onCompleted, thisArg, 0); + return new AnonymousObservable(function(observer) { + var index = 0; + return source.subscribe(function(x) { + var result; + try { + result = onNextFunc(x, index++); + } catch (e) { + observer.onError(e); + return ; + } + isPromise(result) && (result = observableFromPromise(result)); + observer.onNext(result); + }, function(err) { + var result; + try { + result = onErrorFunc(err); + } catch (e) { + observer.onError(e); + return ; + } + isPromise(result) && (result = observableFromPromise(result)); + observer.onNext(result); + observer.onCompleted(); + }, function() { + var result; + try { + result = onCompletedFunc(); + } catch (e) { + observer.onError(e); + return ; + } + isPromise(result) && (result = observableFromPromise(result)); + observer.onNext(result); + observer.onCompleted(); + }); + }, this).concatAll(); + }; + observableProto.defaultIfEmpty = function(defaultValue) { + var source = this; + defaultValue === undefined && (defaultValue = null); + return new AnonymousObservable(function(observer) { + var found = false; + return source.subscribe(function(x) { + found = true; + observer.onNext(x); + }, function(e) { + observer.onError(e); + }, function() { + !found && observer.onNext(defaultValue); + observer.onCompleted(); + }); + }, source); + }; + function arrayIndexOfComparer(array, item, comparer) { + for (var i = 0, + len = array.length; i < len; i++) { + if (comparer(array[i], item)) { + return i; + } + } + return -1; + } + function HashSet(comparer) { + this.comparer = comparer; + this.set = []; + } + HashSet.prototype.push = function(value) { + var retValue = arrayIndexOfComparer(this.set, value, this.comparer) === -1; + retValue && this.set.push(value); + return retValue; + }; + observableProto.distinct = function(keySelector, comparer) { + var source = this; + comparer || (comparer = defaultComparer); + return new AnonymousObservable(function(o) { + var hashSet = new HashSet(comparer); + return source.subscribe(function(x) { + var key = x; + if (keySelector) { + try { + key = keySelector(x); + } catch (e) { + o.onError(e); + return ; } - return bindings; - }, - error: function(message) { - var index = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(message, assert.type.string, index, int); - if (isBlank(index)) - index = this.index; - var location = (index < this.tokens.length) ? ("at column " + (this.tokens[index].index + 1) + " in") : "at the end of the expression"; - throw new BaseException(("Parser Error: " + message + " " + location + " [" + this.input + "] in " + this.location)); } - }, {}); - }()); - Object.defineProperty(_ParseAST, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any], [List], [Reflector], [assert.type.boolean]]; - }}); - Object.defineProperty(_ParseAST.prototype.peek, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(_ParseAST.prototype.optionalCharacter, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(_ParseAST.prototype.expectCharacter, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(_ParseAST.prototype.optionalOperator, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(_ParseAST.prototype.expectOperator, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(_ParseAST.prototype.parseExpressionList, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(_ParseAST.prototype.error, "parameters", {get: function() { - return [[assert.type.string], [int]]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/parser/locals", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/parser/locals"; - var assert, - isPresent, - BaseException, - ListWrapper, - MapWrapper, - Locals; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - BaseException = $__m.BaseException; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - }], - execute: function() { - Locals = (function() { - function Locals(parent, current) { - assert.argumentTypes(parent, Locals, current, Map); - this.parent = parent; - this.current = current; + hashSet.push(key) && o.onNext(x); + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, this); + }; + var MapObservable = (function(__super__) { + inherits(MapObservable, __super__); + function MapObservable(source, selector, thisArg) { + this.source = source; + this.selector = bindCallback(selector, thisArg, 3); + __super__.call(this); + } + MapObservable.prototype.internalMap = function(selector, thisArg) { + var self = this; + return new MapObservable(this.source, function(x, i, o) { + return selector.call(this, self.selector(x, i, o), i, o); + }, thisArg); + }; + MapObservable.prototype.subscribeCore = function(observer) { + return this.source.subscribe(new MapObserver(observer, this.selector, this)); + }; + return MapObservable; + }(ObservableBase)); + function MapObserver(observer, selector, source) { + this.observer = observer; + this.selector = selector; + this.source = source; + this.i = 0; + this.isStopped = false; + } + MapObserver.prototype.onNext = function(x) { + if (this.isStopped) { + return ; + } + var result = tryCatch(this.selector).call(this, x, this.i++, this.source); + if (result === errorObj) { + return this.observer.onError(result.e); + } + this.observer.onNext(result); + }; + MapObserver.prototype.onError = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onError(e); + } + }; + MapObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onCompleted(); + } + }; + MapObserver.prototype.dispose = function() { + this.isStopped = true; + }; + MapObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onError(e); + return true; + } + return false; + }; + observableProto.map = observableProto.select = function(selector, thisArg) { + var selectorFn = typeof selector === 'function' ? selector : function() { + return selector; + }; + return this instanceof MapObservable ? this.internalMap(selectorFn, thisArg) : new MapObservable(this, selectorFn, thisArg); + }; + observableProto.pluck = function() { + var args = arguments, + len = arguments.length; + if (len === 0) { + throw new Error('List of properties cannot be empty.'); + } + return this.map(function(x) { + var currentProp = x; + for (var i = 0; i < len; i++) { + var p = currentProp[args[i]]; + if (typeof p !== 'undefined') { + currentProp = p; + } else { + return undefined; + } } - return ($traceurRuntime.createClass)(Locals, { - contains: function(name) { - assert.argumentTypes(name, assert.type.string); - if (MapWrapper.contains(this.current, name)) { - return assert.returnType((true), assert.type.boolean); - } - if (isPresent(this.parent)) { - return assert.returnType((this.parent.contains(name)), assert.type.boolean); - } - return assert.returnType((false), assert.type.boolean); - }, - get: function(name) { - assert.argumentTypes(name, assert.type.string); - if (MapWrapper.contains(this.current, name)) { - return MapWrapper.get(this.current, name); + return currentProp; + }); + }; + observableProto.flatMapObserver = observableProto.selectManyObserver = function(onNext, onError, onCompleted, thisArg) { + var source = this; + return new AnonymousObservable(function(observer) { + var index = 0; + return source.subscribe(function(x) { + var result; + try { + result = onNext.call(thisArg, x, index++); + } catch (e) { + observer.onError(e); + return ; + } + isPromise(result) && (result = observableFromPromise(result)); + observer.onNext(result); + }, function(err) { + var result; + try { + result = onError.call(thisArg, err); + } catch (e) { + observer.onError(e); + return ; + } + isPromise(result) && (result = observableFromPromise(result)); + observer.onNext(result); + observer.onCompleted(); + }, function() { + var result; + try { + result = onCompleted.call(thisArg); + } catch (e) { + observer.onError(e); + return ; + } + isPromise(result) && (result = observableFromPromise(result)); + observer.onNext(result); + observer.onCompleted(); + }); + }, source).mergeAll(); + }; + function flatMap(source, selector, thisArg) { + var selectorFunc = bindCallback(selector, thisArg, 3); + return source.map(function(x, i) { + var result = selectorFunc(x, i, source); + isPromise(result) && (result = observableFromPromise(result)); + (isArrayLike(result) || isIterable(result)) && (result = observableFrom(result)); + return result; + }).mergeAll(); + } + observableProto.selectMany = observableProto.flatMap = function(selector, resultSelector, thisArg) { + if (isFunction(selector) && isFunction(resultSelector)) { + return this.flatMap(function(x, i) { + var selectorResult = selector(x, i); + isPromise(selectorResult) && (selectorResult = observableFromPromise(selectorResult)); + (isArrayLike(selectorResult) || isIterable(selectorResult)) && (selectorResult = observableFrom(selectorResult)); + return selectorResult.map(function(y, i2) { + return resultSelector(x, y, i, i2); + }); + }, thisArg); + } + return isFunction(selector) ? flatMap(this, selector, thisArg) : flatMap(this, function() { + return selector; + }); + }; + observableProto.selectSwitch = observableProto.flatMapLatest = observableProto.switchMap = function(selector, thisArg) { + return this.select(selector, thisArg).switchLatest(); + }; + observableProto.skip = function(count) { + if (count < 0) { + throw new ArgumentOutOfRangeError(); + } + var source = this; + return new AnonymousObservable(function(o) { + var remaining = count; + return source.subscribe(function(x) { + if (remaining <= 0) { + o.onNext(x); + } else { + remaining--; + } + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, source); + }; + observableProto.skipWhile = function(predicate, thisArg) { + var source = this, + callback = bindCallback(predicate, thisArg, 3); + return new AnonymousObservable(function(o) { + var i = 0, + running = false; + return source.subscribe(function(x) { + if (!running) { + try { + running = !callback(x, i++, source); + } catch (e) { + o.onError(e); + return ; } - if (isPresent(this.parent)) { - return this.parent.get(name); + } + running && o.onNext(x); + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, source); + }; + observableProto.take = function(count, scheduler) { + if (count < 0) { + throw new ArgumentOutOfRangeError(); + } + if (count === 0) { + return observableEmpty(scheduler); + } + var source = this; + return new AnonymousObservable(function(o) { + var remaining = count; + return source.subscribe(function(x) { + if (remaining-- > 0) { + o.onNext(x); + remaining === 0 && o.onCompleted(); + } + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, source); + }; + observableProto.takeWhile = function(predicate, thisArg) { + var source = this, + callback = bindCallback(predicate, thisArg, 3); + return new AnonymousObservable(function(o) { + var i = 0, + running = true; + return source.subscribe(function(x) { + if (running) { + try { + running = callback(x, i++, source); + } catch (e) { + o.onError(e); + return ; } - throw new BaseException(("Cannot find '" + name + "'")); - }, - set: function(name, value) { - assert.argumentTypes(name, assert.type.string, value, assert.type.any); - if (MapWrapper.contains(this.current, name)) { - MapWrapper.set(this.current, name, value); + if (running) { + o.onNext(x); } else { - throw new BaseException('Setting of new keys post-construction is not supported.'); + o.onCompleted(); } - }, - clearValues: function() { - MapWrapper.clearValues(this.current); } - }, {}); - }()); - $__export("Locals", Locals); - Object.defineProperty(Locals, "parameters", {get: function() { - return [[Locals], [Map]]; - }}); - Object.defineProperty(Locals.prototype.contains, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(Locals.prototype.get, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(Locals.prototype.set, "parameters", {get: function() { - return [[assert.type.string], []]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/constants", [], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/constants"; - var CHECK_ONCE, - CHECKED, - CHECK_ALWAYS, - DETACHED, - ON_PUSH, - DEFAULT; - return { - setters: [], - execute: function() { - CHECK_ONCE = "CHECK_ONCE"; - $__export("CHECK_ONCE", CHECK_ONCE); - CHECKED = "CHECKED"; - $__export("CHECKED", CHECKED); - CHECK_ALWAYS = "ALWAYS_CHECK"; - $__export("CHECK_ALWAYS", CHECK_ALWAYS); - DETACHED = "DETACHED"; - $__export("DETACHED", DETACHED); - ON_PUSH = "ON_PUSH"; - $__export("ON_PUSH", ON_PUSH); - DEFAULT = "DEFAULT"; - $__export("DEFAULT", DEFAULT); + }, function(e) { + o.onError(e); + }, function() { + o.onCompleted(); + }); + }, source); + }; + var FilterObservable = (function(__super__) { + inherits(FilterObservable, __super__); + function FilterObservable(source, predicate, thisArg) { + this.source = source; + this.predicate = bindCallback(predicate, thisArg, 3); + __super__.call(this); + } + FilterObservable.prototype.subscribeCore = function(observer) { + return this.source.subscribe(new FilterObserver(observer, this.predicate, this)); + }; + FilterObservable.prototype.internalFilter = function(predicate, thisArg) { + var self = this; + return new FilterObservable(this.source, function(x, i, o) { + return self.predicate(x, i, o) && predicate.call(this, x, i, o); + }, thisArg); + }; + return FilterObservable; + }(ObservableBase)); + function FilterObserver(observer, predicate, source) { + this.observer = observer; + this.predicate = predicate; + this.source = source; + this.i = 0; + this.isStopped = false; } - }; -}); - -System.register("angular2/src/change_detection/interfaces", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/change_detection/parser/locals", "angular2/src/change_detection/constants", "angular2/src/change_detection/binding_record"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/interfaces"; - var assert, - List, - Locals, - DEFAULT, - BindingRecord, - ProtoChangeDetector, - ChangeDetection, - ChangeDispatcher, - ChangeDetector; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - List = $__m.List; - }, function($__m) { - Locals = $__m.Locals; - }, function($__m) { - DEFAULT = $__m.DEFAULT; - }, function($__m) { - BindingRecord = $__m.BindingRecord; - }], - execute: function() { - ProtoChangeDetector = (function() { - function ProtoChangeDetector() {} - return ($traceurRuntime.createClass)(ProtoChangeDetector, {instantiate: function(dispatcher, bindingRecords, variableBindings, directiveRecords) { - assert.argumentTypes(dispatcher, assert.type.any, bindingRecords, List, variableBindings, List, directiveRecords, List); - return assert.returnType((null), ChangeDetector); - }}, {}); - }()); - $__export("ProtoChangeDetector", ProtoChangeDetector); - Object.defineProperty(ProtoChangeDetector.prototype.instantiate, "parameters", {get: function() { - return [[assert.type.any], [List], [List], [List]]; - }}); - ChangeDetection = (function() { - function ChangeDetection() {} - return ($traceurRuntime.createClass)(ChangeDetection, {createProtoChangeDetector: function(name) { - var changeControlStrategy = arguments[1] !== (void 0) ? arguments[1] : DEFAULT; - assert.argumentTypes(name, assert.type.string, changeControlStrategy, assert.type.string); - return assert.returnType((null), ProtoChangeDetector); - }}, {}); - }()); - $__export("ChangeDetection", ChangeDetection); - Object.defineProperty(ChangeDetection.prototype.createProtoChangeDetector, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - ChangeDispatcher = (function() { - function ChangeDispatcher() {} - return ($traceurRuntime.createClass)(ChangeDispatcher, {notifyOnBinding: function(bindingRecord, value) { - assert.argumentTypes(bindingRecord, BindingRecord, value, assert.type.any); - }}, {}); - }()); - $__export("ChangeDispatcher", ChangeDispatcher); - Object.defineProperty(ChangeDispatcher.prototype.notifyOnBinding, "parameters", {get: function() { - return [[BindingRecord], [assert.type.any]]; - }}); - ChangeDetector = (function() { - function ChangeDetector() {} - return ($traceurRuntime.createClass)(ChangeDetector, { - addChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); - }, - addShadowDomChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); - }, - removeChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); - }, - removeShadowDomChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); + FilterObserver.prototype.onNext = function(x) { + if (this.isStopped) { + return ; + } + var shouldYield = tryCatch(this.predicate).call(this, x, this.i++, this.source); + if (shouldYield === errorObj) { + return this.observer.onError(shouldYield.e); + } + shouldYield && this.observer.onNext(x); + }; + FilterObserver.prototype.onError = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onError(e); + } + }; + FilterObserver.prototype.onCompleted = function() { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onCompleted(); + } + }; + FilterObserver.prototype.dispose = function() { + this.isStopped = true; + }; + FilterObserver.prototype.fail = function(e) { + if (!this.isStopped) { + this.isStopped = true; + this.observer.onError(e); + return true; + } + return false; + }; + observableProto.filter = observableProto.where = function(predicate, thisArg) { + return this instanceof FilterObservable ? this.internalFilter(predicate, thisArg) : new FilterObservable(this, predicate, thisArg); + }; + observableProto.transduce = function(transducer) { + var source = this; + function transformForObserver(o) { + return { + '@@transducer/init': function() { + return o; }, - remove: function() {}, - hydrate: function(context, locals, directives) { - assert.argumentTypes(context, assert.type.any, locals, Locals, directives, assert.type.any); + '@@transducer/step': function(obs, input) { + return obs.onNext(input); }, - dehydrate: function() {}, - markPathToRootAsCheckOnce: function() {}, - detectChanges: function() {}, - checkNoChanges: function() {} - }, {}); - }()); - $__export("ChangeDetector", ChangeDetector); - Object.defineProperty(ChangeDetector.prototype.addChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(ChangeDetector.prototype.addShadowDomChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(ChangeDetector.prototype.removeChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(ChangeDetector.prototype.removeShadowDomChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(ChangeDetector.prototype.hydrate, "parameters", {get: function() { - return [[assert.type.any], [Locals], [assert.type.any]]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/pipes/pipe", ["rtts_assert/rtts_assert"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/pipes/pipe"; - var assert, - WrappedValue, - _wrappedValues, - _wrappedIndex, - Pipe; - return { - setters: [function($__m) { - assert = $__m.assert; - }], - execute: function() { - WrappedValue = (function() { - function WrappedValue(wrapped) { - assert.argumentTypes(wrapped, assert.type.any); - this.wrapped = wrapped; + '@@transducer/result': function(obs) { + return obs.onCompleted(); + } + }; + } + return new AnonymousObservable(function(o) { + var xform = transducer(transformForObserver(o)); + return source.subscribe(function(v) { + try { + xform['@@transducer/step'](o, v); + } catch (e) { + o.onError(e); + } + }, function(e) { + o.onError(e); + }, function() { + xform['@@transducer/result'](o); + }); + }, source); + }; + var AnonymousObservable = Rx.AnonymousObservable = (function(__super__) { + inherits(AnonymousObservable, __super__); + function fixSubscriber(subscriber) { + return subscriber && isFunction(subscriber.dispose) ? subscriber : isFunction(subscriber) ? disposableCreate(subscriber) : disposableEmpty; + } + function setDisposable(s, state) { + var ado = state[0], + subscribe = state[1]; + var sub = tryCatch(subscribe)(ado); + if (sub === errorObj) { + if (!ado.fail(errorObj.e)) { + return thrower(errorObj.e); + } + } + ado.setDisposable(fixSubscriber(sub)); + } + function AnonymousObservable(subscribe, parent) { + this.source = parent; + function s(observer) { + var ado = new AutoDetachObserver(observer), + state = [ado, subscribe]; + if (currentThreadScheduler.scheduleRequired()) { + currentThreadScheduler.scheduleWithState(state, setDisposable); + } else { + setDisposable(null, state); + } + return ado; + } + __super__.call(this, s); + } + return AnonymousObservable; + }(Observable)); + var AutoDetachObserver = (function(__super__) { + inherits(AutoDetachObserver, __super__); + function AutoDetachObserver(observer) { + __super__.call(this); + this.observer = observer; + this.m = new SingleAssignmentDisposable(); + } + var AutoDetachObserverPrototype = AutoDetachObserver.prototype; + AutoDetachObserverPrototype.next = function(value) { + var result = tryCatch(this.observer.onNext).call(this.observer, value); + if (result === errorObj) { + this.dispose(); + thrower(result.e); + } + }; + AutoDetachObserverPrototype.error = function(err) { + var result = tryCatch(this.observer.onError).call(this.observer, err); + this.dispose(); + result === errorObj && thrower(result.e); + }; + AutoDetachObserverPrototype.completed = function() { + var result = tryCatch(this.observer.onCompleted).call(this.observer); + this.dispose(); + result === errorObj && thrower(result.e); + }; + AutoDetachObserverPrototype.setDisposable = function(value) { + this.m.setDisposable(value); + }; + AutoDetachObserverPrototype.getDisposable = function() { + return this.m.getDisposable(); + }; + AutoDetachObserverPrototype.dispose = function() { + __super__.prototype.dispose.call(this); + this.m.dispose(); + }; + return AutoDetachObserver; + }(AbstractObserver)); + var InnerSubscription = function(subject, observer) { + this.subject = subject; + this.observer = observer; + }; + InnerSubscription.prototype.dispose = function() { + if (!this.subject.isDisposed && this.observer !== null) { + var idx = this.subject.observers.indexOf(this.observer); + this.subject.observers.splice(idx, 1); + this.observer = null; + } + }; + var Subject = Rx.Subject = (function(__super__) { + function subscribe(observer) { + checkDisposed(this); + if (!this.isStopped) { + this.observers.push(observer); + return new InnerSubscription(this, observer); } - return ($traceurRuntime.createClass)(WrappedValue, {}, {wrap: function(value) { - assert.argumentTypes(value, assert.type.any); - var w = _wrappedValues[_wrappedIndex++ % 5]; - w.wrapped = value; - return assert.returnType((w), WrappedValue); - }}); - }()); - $__export("WrappedValue", WrappedValue); - Object.defineProperty(WrappedValue, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - Object.defineProperty(WrappedValue.wrap, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - _wrappedValues = [new WrappedValue(null), new WrappedValue(null), new WrappedValue(null), new WrappedValue(null), new WrappedValue(null)]; - _wrappedIndex = 0; - Pipe = (function() { - function Pipe() {} - return ($traceurRuntime.createClass)(Pipe, { - supports: function(obj) { - return assert.returnType((false), assert.type.boolean); - }, - onDestroy: function() {}, - transform: function(value) { - assert.argumentTypes(value, assert.type.any); - return assert.returnType((null), assert.type.any); + if (this.hasError) { + observer.onError(this.error); + return disposableEmpty; + } + observer.onCompleted(); + return disposableEmpty; + } + inherits(Subject, __super__); + function Subject() { + __super__.call(this, subscribe); + this.isDisposed = false, this.isStopped = false, this.observers = []; + this.hasError = false; + } + addProperties(Subject.prototype, Observer.prototype, { + hasObservers: function() { + return this.observers.length > 0; + }, + onCompleted: function() { + checkDisposed(this); + if (!this.isStopped) { + this.isStopped = true; + for (var i = 0, + os = cloneArray(this.observers), + len = os.length; i < len; i++) { + os[i].onCompleted(); + } + this.observers.length = 0; } - }, {}); - }()); - $__export("Pipe", Pipe); - Object.defineProperty(Pipe.prototype.transform, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/change_detector_ref", ["rtts_assert/rtts_assert", "angular2/src/change_detection/interfaces", "angular2/src/change_detection/constants"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/change_detector_ref"; - var assert, - ChangeDetector, - CHECK_ONCE, - DETACHED, - CHECK_ALWAYS, - ChangeDetectorRef; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - ChangeDetector = $__m.ChangeDetector; - }, function($__m) { - CHECK_ONCE = $__m.CHECK_ONCE; - DETACHED = $__m.DETACHED; - CHECK_ALWAYS = $__m.CHECK_ALWAYS; - }], - execute: function() { - ChangeDetectorRef = (function() { - function ChangeDetectorRef(cd) { - assert.argumentTypes(cd, ChangeDetector); - this._cd = cd; + }, + onError: function(error) { + checkDisposed(this); + if (!this.isStopped) { + this.isStopped = true; + this.error = error; + this.hasError = true; + for (var i = 0, + os = cloneArray(this.observers), + len = os.length; i < len; i++) { + os[i].onError(error); + } + this.observers.length = 0; + } + }, + onNext: function(value) { + checkDisposed(this); + if (!this.isStopped) { + for (var i = 0, + os = cloneArray(this.observers), + len = os.length; i < len; i++) { + os[i].onNext(value); + } + } + }, + dispose: function() { + this.isDisposed = true; + this.observers = null; } - return ($traceurRuntime.createClass)(ChangeDetectorRef, { - requestCheck: function() { - this._cd.markPathToRootAsCheckOnce(); - }, - detach: function() { - this._cd.mode = DETACHED; - }, - reattach: function() { - this._cd.mode = CHECK_ALWAYS; - this.requestCheck(); + }); + Subject.create = function(observer, observable) { + return new AnonymousSubject(observer, observable); + }; + return Subject; + }(Observable)); + var AsyncSubject = Rx.AsyncSubject = (function(__super__) { + function subscribe(observer) { + checkDisposed(this); + if (!this.isStopped) { + this.observers.push(observer); + return new InnerSubscription(this, observer); + } + if (this.hasError) { + observer.onError(this.error); + } else if (this.hasValue) { + observer.onNext(this.value); + observer.onCompleted(); + } else { + observer.onCompleted(); + } + return disposableEmpty; + } + inherits(AsyncSubject, __super__); + function AsyncSubject() { + __super__.call(this, subscribe); + this.isDisposed = false; + this.isStopped = false; + this.hasValue = false; + this.observers = []; + this.hasError = false; + } + addProperties(AsyncSubject.prototype, Observer, { + hasObservers: function() { + checkDisposed(this); + return this.observers.length > 0; + }, + onCompleted: function() { + var i, + len; + checkDisposed(this); + if (!this.isStopped) { + this.isStopped = true; + var os = cloneArray(this.observers), + len = os.length; + if (this.hasValue) { + for (i = 0; i < len; i++) { + var o = os[i]; + o.onNext(this.value); + o.onCompleted(); + } + } else { + for (i = 0; i < len; i++) { + os[i].onCompleted(); + } + } + this.observers.length = 0; } - }, {}); - }()); - $__export("ChangeDetectorRef", ChangeDetectorRef); - Object.defineProperty(ChangeDetectorRef, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/pipes/pipe_registry", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe", "angular2/di", "angular2/src/change_detection/change_detector_ref"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/pipes/pipe_registry"; - var assert, - List, - ListWrapper, - isBlank, - isPresent, - BaseException, - CONST, - Pipe, - Injectable, - ChangeDetectorRef, - PipeRegistry; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - BaseException = $__m.BaseException; - CONST = $__m.CONST; - }, function($__m) { - Pipe = $__m.Pipe; - }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { - ChangeDetectorRef = $__m.ChangeDetectorRef; - }], - execute: function() { - PipeRegistry = (function() { - function PipeRegistry(config) { - this.config = config; + }, + onError: function(error) { + checkDisposed(this); + if (!this.isStopped) { + this.isStopped = true; + this.hasError = true; + this.error = error; + for (var i = 0, + os = cloneArray(this.observers), + len = os.length; i < len; i++) { + os[i].onError(error); + } + this.observers.length = 0; + } + }, + onNext: function(value) { + checkDisposed(this); + if (this.isStopped) { + return ; + } + this.value = value; + this.hasValue = true; + }, + dispose: function() { + this.isDisposed = true; + this.observers = null; + this.exception = null; + this.value = null; + } + }); + return AsyncSubject; + }(Observable)); + var AnonymousSubject = Rx.AnonymousSubject = (function(__super__) { + inherits(AnonymousSubject, __super__); + function subscribe(observer) { + return this.observable.subscribe(observer); + } + function AnonymousSubject(observer, observable) { + this.observer = observer; + this.observable = observable; + __super__.call(this, subscribe); + } + addProperties(AnonymousSubject.prototype, Observer.prototype, { + onCompleted: function() { + this.observer.onCompleted(); + }, + onError: function(error) { + this.observer.onError(error); + }, + onNext: function(value) { + this.observer.onNext(value); } - return ($traceurRuntime.createClass)(PipeRegistry, {get: function(type, obj, cdRef) { - var listOfConfigs = this.config[type]; - if (isBlank(listOfConfigs)) { - throw new BaseException(("Cannot find '" + type + "' pipe supporting object '" + obj + "'")); - } - var matchingConfig = ListWrapper.find(listOfConfigs, (function(pipeConfig) { - return pipeConfig.supports(obj); - })); - if (isBlank(matchingConfig)) { - throw new BaseException(("Cannot find '" + type + "' pipe supporting object '" + obj + "'")); - } - return assert.returnType((matchingConfig.create(cdRef)), Pipe); - }}, {}); - }()); - $__export("PipeRegistry", PipeRegistry); - Object.defineProperty(PipeRegistry, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(PipeRegistry.prototype.get, "parameters", {get: function() { - return [[assert.type.string], [], [ChangeDetectorRef]]; - }}); + }); + return AnonymousSubject; + }(Observable)); + if (typeof define == 'function' && typeof define.amd == 'object' && define.amd) { + root.Rx = Rx; + define(function() { + return Rx; + }); + } else if (freeExports && freeModule) { + if (moduleExports) { + (freeModule.exports = Rx).Rx = Rx; + } else { + freeExports.Rx = Rx; + } + } else { + root.Rx = Rx; } - }; + var rEndingLine = captureLine(); + }.call(this)); + global.define = __define; + return module.exports; }); -System.register("angular2/src/change_detection/change_detection_jit_generator", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/abstract_change_detector", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/directive_record", "angular2/src/change_detection/proto_record"], function($__export) { +System.register("angular2/src/facade/lang", [], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/change_detection_jit_generator"; - var assert, - isPresent, - isBlank, - BaseException, + var __moduleName = "angular2/src/facade/lang"; + var _global, + __esModule, Type, - List, - ListWrapper, - MapWrapper, - StringMapWrapper, - AbstractChangeDetector, - ChangeDetectionUtil, - DirectiveIndex, - DirectiveRecord, - ProtoRecord, - RECORD_TYPE_SELF, - RECORD_TYPE_PROPERTY, - RECORD_TYPE_LOCAL, - RECORD_TYPE_INVOKE_METHOD, - RECORD_TYPE_CONST, - RECORD_TYPE_INVOKE_CLOSURE, - RECORD_TYPE_PRIMITIVE_OP, - RECORD_TYPE_KEYED_ACCESS, - RECORD_TYPE_PIPE, - RECORD_TYPE_BINDING_PIPE, - RECORD_TYPE_INTERPOLATE, - ABSTRACT_CHANGE_DETECTOR, - UTIL, - DISPATCHER_ACCESSOR, - PIPE_REGISTRY_ACCESSOR, - PROTOS_ACCESSOR, - DIRECTIVES_ACCESSOR, - CONTEXT_ACCESSOR, - IS_CHANGED_LOCAL, - CHANGES_LOCAL, - LOCALS_ACCESSOR, - MODE_ACCESSOR, - TEMP_LOCAL, - CURRENT_PROTO, - ChangeDetectorJITGenerator; - function typeTemplate(type, cons, detectChanges, notifyOnAllChangesDone, setContext) { - assert.argumentTypes(type, assert.type.string, cons, assert.type.string, detectChanges, assert.type.string, notifyOnAllChangesDone, assert.type.string, setContext, assert.type.string); - return assert.returnType((("\n" + cons + "\n" + detectChanges + "\n" + notifyOnAllChangesDone + "\n" + setContext + ";\n\nreturn function(dispatcher, pipeRegistry) {\n return new " + type + "(dispatcher, pipeRegistry, protos, directiveRecords);\n}\n")), assert.type.string); - } - function constructorTemplate(type, fieldsDefinitions) { - assert.argumentTypes(type, assert.type.string, fieldsDefinitions, assert.type.string); - return assert.returnType((("\nvar " + type + " = function " + type + "(dispatcher, pipeRegistry, protos, directiveRecords) {\n" + ABSTRACT_CHANGE_DETECTOR + ".call(this);\n" + DISPATCHER_ACCESSOR + " = dispatcher;\n" + PIPE_REGISTRY_ACCESSOR + " = pipeRegistry;\n" + PROTOS_ACCESSOR + " = protos;\n" + DIRECTIVES_ACCESSOR + " = directiveRecords;\n" + LOCALS_ACCESSOR + " = null;\n" + fieldsDefinitions + "\n}\n\n" + type + ".prototype = Object.create(" + ABSTRACT_CHANGE_DETECTOR + ".prototype);\n")), assert.type.string); - } - function pipeOnDestroyTemplate(pipeNames) { - return pipeNames.map((function(p) { - return (p + ".onDestroy()"); - })).join("\n"); - } - function hydrateTemplate(type, mode, fieldDefinitions, pipeOnDestroy, directiveFieldNames, detectorFieldNames) { - assert.argumentTypes(type, assert.type.string, mode, assert.type.string, fieldDefinitions, assert.type.string, pipeOnDestroy, assert.type.string, directiveFieldNames, assert.genericType(List, String), detectorFieldNames, assert.genericType(List, String)); - var directiveInit = ""; - for (var i = 0; i < directiveFieldNames.length; ++i) { - directiveInit += (directiveFieldNames[i] + " = directives.getDirectiveFor(this.directiveRecords[" + i + "].directiveIndex);\n"); - } - var detectorInit = ""; - for (var i = 0; i < detectorFieldNames.length; ++i) { - detectorInit += (detectorFieldNames[i] + " = directives.getDetectorFor(this.directiveRecords[" + i + "].directiveIndex);\n"); - } - return assert.returnType((("\n" + type + ".prototype.hydrate = function(context, locals, directives) {\n " + MODE_ACCESSOR + " = \"" + mode + "\";\n " + CONTEXT_ACCESSOR + " = context;\n " + LOCALS_ACCESSOR + " = locals;\n " + directiveInit + "\n " + detectorInit + "\n}\n" + type + ".prototype.dehydrate = function() {\n " + pipeOnDestroy + "\n " + fieldDefinitions + "\n " + LOCALS_ACCESSOR + " = null;\n}\n" + type + ".prototype.hydrated = function() {\n return " + CONTEXT_ACCESSOR + " !== " + UTIL + ".unitialized();\n}\n")), assert.type.string); - } - function detectChangesTemplate(type, body) { - assert.argumentTypes(type, assert.type.string, body, assert.type.string); - return assert.returnType((("\n" + type + ".prototype.detectChangesInRecords = function(throwOnChange) {\n " + body + "\n}\n")), assert.type.string); - } - function callOnAllChangesDoneTemplate(type, body) { - assert.argumentTypes(type, assert.type.string, body, assert.type.string); - return assert.returnType((("\n" + type + ".prototype.callOnAllChangesDone = function() {\n " + body + "\n}\n")), assert.type.string); - } - function onAllChangesDoneTemplate(directive) { - assert.argumentTypes(directive, assert.type.string); - return assert.returnType(((directive + ".onAllChangesDone();")), assert.type.string); - } - function detectChangesBodyTemplate(localDefinitions, changeDefinitions, records) { - assert.argumentTypes(localDefinitions, assert.type.string, changeDefinitions, assert.type.string, records, assert.type.string); - return assert.returnType((("\n" + localDefinitions + "\n" + changeDefinitions + "\nvar " + TEMP_LOCAL + ";\nvar " + IS_CHANGED_LOCAL + " = false;\nvar " + CURRENT_PROTO + ";\nvar " + CHANGES_LOCAL + " = null;\n\ncontext = " + CONTEXT_ACCESSOR + ";\n" + records + "\n")), assert.type.string); - } - function pipeCheckTemplate(protoIndex, context, bindingPropagationConfig, pipe, pipeType, oldValue, newValue, change, update, addToChanges, lastInDirective) { - assert.argumentTypes(protoIndex, assert.type.number, context, assert.type.string, bindingPropagationConfig, assert.type.string, pipe, assert.type.string, pipeType, assert.type.string, oldValue, assert.type.string, newValue, assert.type.string, change, assert.type.string, update, assert.type.string, addToChanges, assert.type.any, lastInDirective, assert.type.string); - return assert.returnType((("\n" + CURRENT_PROTO + " = " + PROTOS_ACCESSOR + "[" + protoIndex + "];\nif (" + pipe + " === " + UTIL + ".unitialized()) {\n " + pipe + " = " + PIPE_REGISTRY_ACCESSOR + ".get('" + pipeType + "', " + context + ", " + bindingPropagationConfig + ");\n} else if (!" + pipe + ".supports(" + context + ")) {\n " + pipe + ".onDestroy();\n " + pipe + " = " + PIPE_REGISTRY_ACCESSOR + ".get('" + pipeType + "', " + context + ", " + bindingPropagationConfig + ");\n}\n\n" + newValue + " = " + pipe + ".transform(" + context + ");\nif (" + oldValue + " !== " + newValue + ") {\n " + newValue + " = " + UTIL + ".unwrapValue(" + newValue + ");\n " + change + " = true;\n " + update + "\n " + addToChanges + "\n " + oldValue + " = " + newValue + ";\n}\n" + lastInDirective + "\n")), assert.type.string); + BaseException, + Math, + Date, + assertionsEnabled_, + int, + ABSTRACT, + IMPLEMENTS, + StringWrapper, + StringJoiner, + NumberParseError, + NumberWrapper, + RegExp, + RegExpWrapper, + RegExpMatcherWrapper, + FunctionWrapper, + Json, + DateWrapper; + function CONST_EXPR(expr) { + return expr; } - function referenceCheckTemplate(protoIndex, assignment, oldValue, newValue, change, update, addToChanges, lastInDirective) { - assert.argumentTypes(protoIndex, assert.type.number, assignment, assert.type.string, oldValue, assert.type.string, newValue, assert.type.string, change, assert.type.string, update, assert.type.string, addToChanges, assert.type.string, lastInDirective, assert.type.string); - return assert.returnType((("\n" + CURRENT_PROTO + " = " + PROTOS_ACCESSOR + "[" + protoIndex + "];\n" + assignment + "\nif (" + newValue + " !== " + oldValue + " || (" + newValue + " !== " + newValue + ") && (" + oldValue + " !== " + oldValue + ")) {\n " + change + " = true;\n " + update + "\n " + addToChanges + "\n " + oldValue + " = " + newValue + ";\n}\n" + lastInDirective + "\n")), assert.type.string); + function CONST() { + return (function(target) { + return target; + }); } - function assignmentTemplate(field, value) { - assert.argumentTypes(field, assert.type.string, value, assert.type.string); - return (field + " = " + value + ";"); + function isPresent(obj) { + return obj !== undefined && obj !== null; } - function localDefinitionsTemplate(names) { - return assert.returnType((names.map((function(n) { - return ("var " + n + ";"); - })).join("\n")), assert.type.string); + function isBlank(obj) { + return obj === undefined || obj === null; } - function changeDefinitionsTemplate(names) { - return assert.returnType((names.map((function(n) { - return ("var " + n + " = false;"); - })).join("\n")), assert.type.string); + function isString(obj) { + return typeof obj === "string"; } - function fieldDefinitionsTemplate(names) { - return assert.returnType((names.map((function(n) { - return (n + " = " + UTIL + ".unitialized();"); - })).join("\n")), assert.type.string); + function isFunction(obj) { + return typeof obj === "function"; } - function ifChangedGuardTemplate(changeNames, body) { - assert.argumentTypes(changeNames, List, body, assert.type.string); - var cond = changeNames.join(" || "); - return assert.returnType((("\nif (" + cond + ") {\n " + body + "\n}\n")), assert.type.string); + function isType(obj) { + return isFunction(obj); } - function addToChangesTemplate(oldValue, newValue) { - assert.argumentTypes(oldValue, assert.type.string, newValue, assert.type.string); - return assert.returnType(((CHANGES_LOCAL + " = " + UTIL + ".addChange(" + CHANGES_LOCAL + ", " + CURRENT_PROTO + ".bindingRecord.propertyName, " + UTIL + ".simpleChange(" + oldValue + ", " + newValue + "));")), assert.type.string); + function stringify(token) { + if (typeof token === 'string') { + return token; + } + if (token === undefined || token === null) { + return '' + token; + } + if (token.name) { + return token.name; + } + return token.toString(); } - function updateDirectiveTemplate(oldValue, newValue, directiveProperty) { - assert.argumentTypes(oldValue, assert.type.string, newValue, assert.type.string, directiveProperty, assert.type.string); - return assert.returnType((("\nif(throwOnChange) " + UTIL + ".throwOnChange(" + CURRENT_PROTO + ", " + UTIL + ".simpleChange(" + oldValue + ", " + newValue + "));\n" + directiveProperty + " = " + newValue + ";\n" + IS_CHANGED_LOCAL + " = true;\n ")), assert.type.string); + function looseIdentical(a, b) { + return a === b || typeof a === "number" && typeof b === "number" && isNaN(a) && isNaN(b); } - function updateElementTemplate(oldValue, newValue) { - assert.argumentTypes(oldValue, assert.type.string, newValue, assert.type.string); - return assert.returnType((("\nif(throwOnChange) " + UTIL + ".throwOnChange(" + CURRENT_PROTO + ", " + UTIL + ".simpleChange(" + oldValue + ", " + newValue + "));\n" + DISPATCHER_ACCESSOR + ".notifyOnBinding(" + CURRENT_PROTO + ".bindingRecord, " + newValue + ");\n ")), assert.type.string); + function getMapKey(value) { + return value; } - function notifyOnChangesTemplate(directive) { - assert.argumentTypes(directive, assert.type.string); - return assert.returnType((("\nif(" + CHANGES_LOCAL + ") {\n " + directive + ".onChange(" + CHANGES_LOCAL + ");\n " + CHANGES_LOCAL + " = null;\n}\n")), assert.type.string); + function normalizeBlank(obj) { + return isBlank(obj) ? null : obj; } - function notifyOnPushDetectorsTemplate(detector) { - assert.argumentTypes(detector, assert.type.string); - return assert.returnType((("\nif(" + IS_CHANGED_LOCAL + ") {\n " + detector + ".markAsCheckOnce();\n}\n")), assert.type.string); + function isJsObject(o) { + return o !== null && (typeof o === "function" || typeof o === "object"); } - function lastInDirectiveTemplate(notifyOnChanges, notifyOnPush) { - assert.argumentTypes(notifyOnChanges, assert.type.string, notifyOnPush, assert.type.string); - return assert.returnType((("\n" + notifyOnChanges + "\n" + notifyOnPush + "\n" + IS_CHANGED_LOCAL + " = false;\n")), assert.type.string); + function assertionsEnabled() { + return assertionsEnabled_; } - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - Type = $__m.Type; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - StringMapWrapper = $__m.StringMapWrapper; - }, function($__m) { - AbstractChangeDetector = $__m.AbstractChangeDetector; - }, function($__m) { - ChangeDetectionUtil = $__m.ChangeDetectionUtil; - }, function($__m) { - DirectiveIndex = $__m.DirectiveIndex; - DirectiveRecord = $__m.DirectiveRecord; - }, function($__m) { - ProtoRecord = $__m.ProtoRecord; - RECORD_TYPE_SELF = $__m.RECORD_TYPE_SELF; - RECORD_TYPE_PROPERTY = $__m.RECORD_TYPE_PROPERTY; - RECORD_TYPE_LOCAL = $__m.RECORD_TYPE_LOCAL; - RECORD_TYPE_INVOKE_METHOD = $__m.RECORD_TYPE_INVOKE_METHOD; - RECORD_TYPE_CONST = $__m.RECORD_TYPE_CONST; - RECORD_TYPE_INVOKE_CLOSURE = $__m.RECORD_TYPE_INVOKE_CLOSURE; - RECORD_TYPE_PRIMITIVE_OP = $__m.RECORD_TYPE_PRIMITIVE_OP; - RECORD_TYPE_KEYED_ACCESS = $__m.RECORD_TYPE_KEYED_ACCESS; - RECORD_TYPE_PIPE = $__m.RECORD_TYPE_PIPE; - RECORD_TYPE_BINDING_PIPE = $__m.RECORD_TYPE_BINDING_PIPE; - RECORD_TYPE_INTERPOLATE = $__m.RECORD_TYPE_INTERPOLATE; - }], - execute: function() { - ABSTRACT_CHANGE_DETECTOR = "AbstractChangeDetector"; - UTIL = "ChangeDetectionUtil"; - DISPATCHER_ACCESSOR = "this.dispatcher"; - PIPE_REGISTRY_ACCESSOR = "this.pipeRegistry"; - PROTOS_ACCESSOR = "this.protos"; - DIRECTIVES_ACCESSOR = "this.directiveRecords"; - CONTEXT_ACCESSOR = "this.context"; - IS_CHANGED_LOCAL = "isChanged"; - CHANGES_LOCAL = "changes"; - LOCALS_ACCESSOR = "this.locals"; - MODE_ACCESSOR = "this.mode"; - TEMP_LOCAL = "temp"; - CURRENT_PROTO = "currentProto"; - Object.defineProperty(typeTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(constructorTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(pipeOnDestroyTemplate, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(hydrateTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.genericType(List, String)], [assert.genericType(List, String)]]; - }}); - Object.defineProperty(detectChangesTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(callOnAllChangesDoneTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(onAllChangesDoneTemplate, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(detectChangesBodyTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(pipeCheckTemplate, "parameters", {get: function() { - return [[assert.type.number], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [], [assert.type.string]]; - }}); - Object.defineProperty(referenceCheckTemplate, "parameters", {get: function() { - return [[assert.type.number], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(assignmentTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(localDefinitionsTemplate, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(changeDefinitionsTemplate, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(fieldDefinitionsTemplate, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(ifChangedGuardTemplate, "parameters", {get: function() { - return [[List], [assert.type.string]]; - }}); - Object.defineProperty(addToChangesTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(updateDirectiveTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(updateElementTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(notifyOnChangesTemplate, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(notifyOnPushDetectorsTemplate, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(lastInDirectiveTemplate, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - ChangeDetectorJITGenerator = (function() { - function ChangeDetectorJITGenerator(typeName, changeDetectionStrategy, records, directiveRecords) { - assert.argumentTypes(typeName, assert.type.string, changeDetectionStrategy, assert.type.string, records, assert.genericType(List, ProtoRecord), directiveRecords, List); - this.typeName = typeName; - this.changeDetectionStrategy = changeDetectionStrategy; - this.records = records; - this.directiveRecords = directiveRecords; - this.localNames = this.getLocalNames(records); - this.changeNames = this.getChangeNames(this.localNames); - this.fieldNames = this.getFieldNames(this.localNames); - this.pipeNames = this.getPipeNames(this.localNames); + function print(obj) { + if (obj instanceof Error) { + console.log(obj.stack); + } else { + console.log(obj); + } + } + $__export("CONST_EXPR", CONST_EXPR); + $__export("CONST", CONST); + $__export("isPresent", isPresent); + $__export("isBlank", isBlank); + $__export("isString", isString); + $__export("isFunction", isFunction); + $__export("isType", isType); + $__export("stringify", stringify); + $__export("looseIdentical", looseIdentical); + $__export("getMapKey", getMapKey); + $__export("normalizeBlank", normalizeBlank); + $__export("isJsObject", isJsObject); + $__export("assertionsEnabled", assertionsEnabled); + $__export("print", print); + return { + setters: [], + execute: function() { + _global = typeof window === 'undefined' ? global : window; + $__export("global", _global); + __esModule = true; + $__export("__esModule", __esModule); + Type = Function; + $__export("Type", Type); + BaseException = (function($__super) { + function BaseException(message) { + $traceurRuntime.superConstructor(BaseException).call(this, message); + this.message = message; + this.stack = (new Error()).stack; } - return ($traceurRuntime.createClass)(ChangeDetectorJITGenerator, { - getLocalNames: function(records) { - assert.argumentTypes(records, assert.genericType(List, ProtoRecord)); - var index = 0; - var names = records.map((function(r) { - var sanitizedName = r.name.replace(new RegExp("\\W", "g"), ''); - return ("" + sanitizedName + index++); - })); - return assert.returnType((["context"].concat(names)), assert.genericType(List, assert.type.string)); - }, - getChangeNames: function(localNames) { - return assert.returnType((localNames.map((function(n) { - return ("change_" + n); - }))), assert.genericType(List, assert.type.string)); - }, - getFieldNames: function(localNames) { - return assert.returnType((localNames.map((function(n) { - return ("this." + n); - }))), assert.genericType(List, assert.type.string)); - }, - getPipeNames: function(localNames) { - return assert.returnType((localNames.map((function(n) { - return ("this." + n + "_pipe"); - }))), assert.genericType(List, assert.type.string)); - }, - generate: function() { - var text = typeTemplate(this.typeName, this.genConstructor(), this.genDetectChanges(), this.genCallOnAllChangesDone(), this.genHydrate()); - return assert.returnType((new Function('AbstractChangeDetector', 'ChangeDetectionUtil', 'protos', 'directiveRecords', text)(AbstractChangeDetector, ChangeDetectionUtil, this.records, this.directiveRecords)), Function); - }, - genConstructor: function() { - return assert.returnType((constructorTemplate(this.typeName, this.genFieldDefinitions())), assert.type.string); - }, - genHydrate: function() { - var mode = ChangeDetectionUtil.changeDetectionMode(this.changeDetectionStrategy); - return assert.returnType((hydrateTemplate(this.typeName, mode, this.genFieldDefinitions(), pipeOnDestroyTemplate(this.getNonNullPipeNames()), this.getDirectiveFieldNames(), this.getDetectorFieldNames())), assert.type.string); - }, - getDirectiveFieldNames: function() { - var $__0 = this; - return assert.returnType((this.directiveRecords.map((function(d) { - return $__0.getDirective(d.directiveIndex); - }))), assert.genericType(List, assert.type.string)); - }, - getDetectorFieldNames: function() { - var $__0 = this; - return assert.returnType((this.directiveRecords.filter((function(r) { - return r.isOnPushChangeDetection(); - })).map((function(d) { - return $__0.getDetector(d.directiveIndex); - }))), assert.genericType(List, assert.type.string)); - }, - getDirective: function(d) { - assert.argumentTypes(d, DirectiveIndex); - return ("this.directive_" + d.name); - }, - getDetector: function(d) { - assert.argumentTypes(d, DirectiveIndex); - return ("this.detector_" + d.name); - }, - genFieldDefinitions: function() { - var fields = []; - fields = fields.concat(this.fieldNames); - fields = fields.concat(this.getNonNullPipeNames()); - fields = fields.concat(this.getDirectiveFieldNames()); - fields = fields.concat(this.getDetectorFieldNames()); - return fieldDefinitionsTemplate(fields); - }, - getNonNullPipeNames: function() { - var $__0 = this; - var pipes = []; - this.records.forEach((function(r) { - if (r.mode === RECORD_TYPE_PIPE || r.mode === RECORD_TYPE_BINDING_PIPE) { - pipes.push($__0.pipeNames[r.selfIndex]); - } - })); - return assert.returnType((pipes), assert.genericType(List, assert.type.string)); + return ($traceurRuntime.createClass)(BaseException, {toString: function() { + return this.message; + }}, {}, $__super); + }(Error)); + $__export("BaseException", BaseException); + Math = _global.Math; + $__export("Math", Math); + Date = _global.Date; + $__export("Date", Date); + assertionsEnabled_ = typeof assert !== 'undefined'; + if (assertionsEnabled_) { + _global.assert = assert; + $__export("int", int = assert.define('int', function(value) { + return typeof value === 'number' && value % 1 === 0; + })); + } else { + $__export("int", int = {}); + _global.assert = function() {}; + } + $__export("int", int); + ABSTRACT = (function() { + function ABSTRACT() {} + return ($traceurRuntime.createClass)(ABSTRACT, {}, {}); + }()); + $__export("ABSTRACT", ABSTRACT); + IMPLEMENTS = (function() { + function IMPLEMENTS() {} + return ($traceurRuntime.createClass)(IMPLEMENTS, {}, {}); + }()); + $__export("IMPLEMENTS", IMPLEMENTS); + StringWrapper = (function() { + function StringWrapper() {} + return ($traceurRuntime.createClass)(StringWrapper, {}, { + fromCharCode: function(code) { + return String.fromCharCode(code); }, - genDetectChanges: function() { - var body = this.genDetectChangesBody(); - return assert.returnType((detectChangesTemplate(this.typeName, body)), assert.type.string); + charCodeAt: function(s, index) { + return s.charCodeAt(index); }, - genCallOnAllChangesDone: function() { - var notifications = []; - var dirs = this.directiveRecords; - for (var i = dirs.length - 1; i >= 0; --i) { - var dir = dirs[i]; - if (dir.callOnAllChangesDone) { - var directive = ("this.directive_" + dir.directiveIndex.name); - notifications.push(onAllChangesDoneTemplate(directive)); - } - } - return assert.returnType((callOnAllChangesDoneTemplate(this.typeName, notifications.join(";\n"))), assert.type.string); + split: function(s, regExp) { + return s.split(regExp); }, - genDetectChangesBody: function() { - var $__0 = this; - var rec = this.records.map((function(r) { - return $__0.genRecord(r); - })).join("\n"); - return assert.returnType((detectChangesBodyTemplate(this.genLocalDefinitions(), this.genChangeDefinitions(), rec)), assert.type.string); + equals: function(s, s2) { + return s === s2; }, - genLocalDefinitions: function() { - return assert.returnType((localDefinitionsTemplate(this.localNames)), assert.type.string); + replace: function(s, from, replace) { + return s.replace(from, replace); }, - genChangeDefinitions: function() { - return assert.returnType((changeDefinitionsTemplate(this.changeNames)), assert.type.string); + replaceAll: function(s, from, replace) { + return s.replace(from, replace); }, - genRecord: function(r) { - assert.argumentTypes(r, ProtoRecord); - if (r.mode === RECORD_TYPE_PIPE || r.mode === RECORD_TYPE_BINDING_PIPE) { - return assert.returnType((this.genPipeCheck(r)), assert.type.string); - } else { - return assert.returnType((this.genReferenceCheck(r)), assert.type.string); - } + startsWith: function(s, start) { + return s.startsWith(start); }, - genPipeCheck: function(r) { - assert.argumentTypes(r, ProtoRecord); - var context = this.localNames[r.contextIndex]; - var oldValue = this.fieldNames[r.selfIndex]; - var newValue = this.localNames[r.selfIndex]; - var change = this.changeNames[r.selfIndex]; - var pipe = this.pipeNames[r.selfIndex]; - var cdRef = r.mode === RECORD_TYPE_BINDING_PIPE ? "this.ref" : "null"; - var update = this.genUpdateDirectiveOrElement(r); - var addToChanges = this.genAddToChanges(r); - var lastInDirective = this.genLastInDirective(r); - return assert.returnType((pipeCheckTemplate(r.selfIndex - 1, context, cdRef, pipe, r.name, oldValue, newValue, change, update, addToChanges, lastInDirective)), assert.type.string); + substring: function(s, start) { + var end = arguments[2] !== (void 0) ? arguments[2] : null; + return s.substring(start, end === null ? undefined : end); }, - genReferenceCheck: function(r) { - assert.argumentTypes(r, ProtoRecord); - var oldValue = this.fieldNames[r.selfIndex]; - var newValue = this.localNames[r.selfIndex]; - var change = this.changeNames[r.selfIndex]; - var assignment = this.genUpdateCurrentValue(r); - var update = this.genUpdateDirectiveOrElement(r); - var addToChanges = this.genAddToChanges(r); - var lastInDirective = this.genLastInDirective(r); - var check = referenceCheckTemplate(r.selfIndex - 1, assignment, oldValue, newValue, change, update, addToChanges, lastInDirective); - if (r.isPureFunction()) { - return assert.returnType((this.ifChangedGuard(r, check)), assert.type.string); - } else { - return assert.returnType((check), assert.type.string); - } + replaceAllMapped: function(s, from, cb) { + return s.replace(from, function() { + for (var matches = [], + $__1 = 0; $__1 < arguments.length; $__1++) + matches[$__1] = arguments[$__1]; + matches.splice(-2, 2); + return cb(matches); + }); }, - genUpdateCurrentValue: function(r) { - assert.argumentTypes(r, ProtoRecord); - var context = this.getContext(r); - var newValue = this.localNames[r.selfIndex]; - var args = this.genArgs(r); - switch (r.mode) { - case RECORD_TYPE_SELF: - return assert.returnType((assignmentTemplate(newValue, context)), assert.type.string); - case RECORD_TYPE_CONST: - return assert.returnType(((newValue + " = " + this.genLiteral(r.funcOrValue))), assert.type.string); - case RECORD_TYPE_PROPERTY: - return assert.returnType((assignmentTemplate(newValue, (context + "." + r.name))), assert.type.string); - case RECORD_TYPE_LOCAL: - return assert.returnType((assignmentTemplate(newValue, (LOCALS_ACCESSOR + ".get('" + r.name + "')"))), assert.type.string); - case RECORD_TYPE_INVOKE_METHOD: - return assert.returnType((assignmentTemplate(newValue, (context + "." + r.name + "(" + args + ")"))), assert.type.string); - case RECORD_TYPE_INVOKE_CLOSURE: - return assert.returnType((assignmentTemplate(newValue, (context + "(" + args + ")"))), assert.type.string); - case RECORD_TYPE_PRIMITIVE_OP: - return assert.returnType((assignmentTemplate(newValue, (UTIL + "." + r.name + "(" + args + ")"))), assert.type.string); - case RECORD_TYPE_INTERPOLATE: - return assert.returnType((assignmentTemplate(newValue, this.genInterpolation(r))), assert.type.string); - case RECORD_TYPE_KEYED_ACCESS: - var key = this.localNames[r.args[0]]; - return assert.returnType((assignmentTemplate(newValue, (context + "[" + key + "]"))), assert.type.string); - default: - throw new BaseException(("Unknown operation " + r.mode)); - } + contains: function(s, substr) { + return s.indexOf(substr) != -1; + } + }); + }()); + $__export("StringWrapper", StringWrapper); + StringJoiner = (function() { + function StringJoiner() { + var parts = arguments[0] !== (void 0) ? arguments[0] : []; + this.parts = parts; + } + return ($traceurRuntime.createClass)(StringJoiner, { + add: function(part) { + this.parts.push(part); }, - getContext: function(r) { - assert.argumentTypes(r, ProtoRecord); - if (r.contextIndex == -1) { - return assert.returnType((this.getDirective(r.directiveIndex)), assert.type.string); - } else { - return assert.returnType((this.localNames[r.contextIndex]), assert.type.string); - } + toString: function() { + return this.parts.join(""); + } + }, {}); + }()); + $__export("StringJoiner", StringJoiner); + NumberParseError = (function($__super) { + function NumberParseError(message) { + $traceurRuntime.superConstructor(NumberParseError).call(this); + this.message = message; + } + return ($traceurRuntime.createClass)(NumberParseError, {toString: function() { + return this.message; + }}, {}, $__super); + }(BaseException)); + $__export("NumberParseError", NumberParseError); + NumberWrapper = (function() { + function NumberWrapper() {} + return ($traceurRuntime.createClass)(NumberWrapper, {}, { + toFixed: function(n, fractionDigits) { + return n.toFixed(fractionDigits); }, - ifChangedGuard: function(r, body) { - var $__0 = this; - return assert.returnType((ifChangedGuardTemplate(r.args.map((function(a) { - return $__0.changeNames[a]; - })), body)), assert.type.string); + equal: function(a, b) { + return a === b; }, - genInterpolation: function(r) { - assert.argumentTypes(r, ProtoRecord); - var res = ""; - for (var i = 0; i < r.args.length; ++i) { - res += this.genLiteral(r.fixedArgs[i]); - res += " + "; - res += this.localNames[r.args[i]]; - res += " + "; + parseIntAutoRadix: function(text) { + var result = parseInt(text); + if (isNaN(result)) { + throw new NumberParseError("Invalid integer literal when parsing " + text); } - res += this.genLiteral(r.fixedArgs[r.args.length]); - return assert.returnType((res), assert.type.string); - }, - genLiteral: function(value) { - return assert.returnType((JSON.stringify(value)), assert.type.string); + return result; }, - genUpdateDirectiveOrElement: function(r) { - assert.argumentTypes(r, ProtoRecord); - if (!r.lastInBinding) - return assert.returnType((""), assert.type.string); - var newValue = this.localNames[r.selfIndex]; - var oldValue = this.fieldNames[r.selfIndex]; - var br = r.bindingRecord; - if (br.isDirective()) { - var directiveProperty = (this.getDirective(br.directiveRecord.directiveIndex) + "." + br.propertyName); - return assert.returnType((updateDirectiveTemplate(oldValue, newValue, directiveProperty)), assert.type.string); + parseInt: function(text, radix) { + if (radix == 10) { + if (/^(\-|\+)?[0-9]+$/.test(text)) { + return parseInt(text, radix); + } + } else if (radix == 16) { + if (/^(\-|\+)?[0-9ABCDEFabcdef]+$/.test(text)) { + return parseInt(text, radix); + } } else { - return assert.returnType((updateElementTemplate(oldValue, newValue)), assert.type.string); + var result = parseInt(text, radix); + if (!isNaN(result)) { + return result; + } } + throw new NumberParseError("Invalid integer literal when parsing " + text + " in base " + radix); }, - genAddToChanges: function(r) { - assert.argumentTypes(r, ProtoRecord); - var newValue = this.localNames[r.selfIndex]; - var oldValue = this.fieldNames[r.selfIndex]; - return assert.returnType((r.bindingRecord.callOnChange() ? addToChangesTemplate(oldValue, newValue) : ""), assert.type.string); + parseFloat: function(text) { + return parseFloat(text); }, - genLastInDirective: function(r) { - assert.argumentTypes(r, ProtoRecord); - var onChanges = this.genNotifyOnChanges(r); - var onPush = this.genNotifyOnPushDetectors(r); - return assert.returnType((lastInDirectiveTemplate(onChanges, onPush)), assert.type.string); + get NaN() { + return NaN; }, - genNotifyOnChanges: function(r) { - assert.argumentTypes(r, ProtoRecord); - var br = r.bindingRecord; - if (r.lastInDirective && br.callOnChange()) { - return assert.returnType((notifyOnChangesTemplate(this.getDirective(br.directiveRecord.directiveIndex))), assert.type.string); - } else { - return assert.returnType((""), assert.type.string); - } + isNaN: function(value) { + return isNaN(value); }, - genNotifyOnPushDetectors: function(r) { - assert.argumentTypes(r, ProtoRecord); - var br = r.bindingRecord; - if (r.lastInDirective && br.isOnPushChangeDetection()) { - return assert.returnType((notifyOnPushDetectorsTemplate(this.getDetector(br.directiveRecord.directiveIndex))), assert.type.string); - } else { - return assert.returnType((""), assert.type.string); - } + isInteger: function(value) { + return Number.isInteger(value); + } + }); + }()); + $__export("NumberWrapper", NumberWrapper); + RegExp = _global.RegExp; + $__export("RegExp", RegExp); + RegExpWrapper = (function() { + function RegExpWrapper() {} + return ($traceurRuntime.createClass)(RegExpWrapper, {}, { + create: function(regExpStr) { + var flags = arguments[1] !== (void 0) ? arguments[1] : ''; + flags = flags.replace(/g/g, ''); + return new _global.RegExp(regExpStr, flags + 'g'); }, - genArgs: function(r) { - var $__0 = this; - return assert.returnType((r.args.map((function(arg) { - return $__0.localNames[arg]; - })).join(", ")), assert.type.string); + firstMatch: function(regExp, input) { + regExp.lastIndex = 0; + return regExp.exec(input); + }, + matcher: function(regExp, input) { + regExp.lastIndex = 0; + return { + re: regExp, + input: input + }; } - }, {}); + }); }()); - $__export("ChangeDetectorJITGenerator", ChangeDetectorJITGenerator); - Object.defineProperty(ChangeDetectorJITGenerator, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.genericType(List, ProtoRecord)], [List]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.getLocalNames, "parameters", {get: function() { - return [[assert.genericType(List, ProtoRecord)]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.getChangeNames, "parameters", {get: function() { - return [[assert.genericType(List, assert.type.string)]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.getFieldNames, "parameters", {get: function() { - return [[assert.genericType(List, assert.type.string)]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.getPipeNames, "parameters", {get: function() { - return [[assert.genericType(List, assert.type.string)]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.getDirective, "parameters", {get: function() { - return [[DirectiveIndex]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.getDetector, "parameters", {get: function() { - return [[DirectiveIndex]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genRecord, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genPipeCheck, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genReferenceCheck, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genUpdateCurrentValue, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.getContext, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.ifChangedGuard, "parameters", {get: function() { - return [[ProtoRecord], [assert.type.string]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genInterpolation, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genUpdateDirectiveOrElement, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genAddToChanges, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genLastInDirective, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genNotifyOnChanges, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genNotifyOnPushDetectors, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(ChangeDetectorJITGenerator.prototype.genArgs, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); + $__export("RegExpWrapper", RegExpWrapper); + RegExpMatcherWrapper = (function() { + function RegExpMatcherWrapper() {} + return ($traceurRuntime.createClass)(RegExpMatcherWrapper, {}, {next: function(matcher) { + return matcher.re.exec(matcher.input); + }}); + }()); + $__export("RegExpMatcherWrapper", RegExpMatcherWrapper); + FunctionWrapper = (function() { + function FunctionWrapper() {} + return ($traceurRuntime.createClass)(FunctionWrapper, {}, {apply: function(fn, posArgs) { + return fn.apply(null, posArgs); + }}); + }()); + $__export("FunctionWrapper", FunctionWrapper); + Json = _global.JSON; + $__export("Json", Json); + DateWrapper = (function() { + function DateWrapper() {} + return ($traceurRuntime.createClass)(DateWrapper, {}, { + fromMillis: function(ms) { + return new Date(ms); + }, + toMillis: function(date) { + return date.getTime(); + }, + now: function() { + return new Date(); + }, + toJson: function(date) { + return date.toJSON(); + } + }); + }()); + $__export("DateWrapper", DateWrapper); } }; }); -System.register("angular2/src/change_detection/coalesce", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/proto_record"], function($__export) { +System.register("angular2/src/facade/collection", ["angular2/src/facade/lang"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/coalesce"; - var assert, - isPresent, + var __moduleName = "angular2/src/facade/collection"; + var isJsObject, + global, + __esModule, List, - ListWrapper, Map, + Set, + StringMap, + createMapFromPairs, MapWrapper, - RECORD_TYPE_SELF, - ProtoRecord; - function coalesce(records) { - assert.argumentTypes(records, assert.genericType(List, ProtoRecord)); - var res = ListWrapper.create(); - var indexMap = MapWrapper.create(); - for (var i = 0; i < records.length; ++i) { - var r = records[i]; - var record = _replaceIndices(r, res.length + 1, indexMap); - var matchingRecord = _findMatching(record, res); - if (isPresent(matchingRecord) && record.lastInBinding) { - ListWrapper.push(res, _selfRecord(record, matchingRecord.selfIndex, res.length + 1)); - MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex); - } else if (isPresent(matchingRecord) && !record.lastInBinding) { - MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex); - } else { - ListWrapper.push(res, record); - MapWrapper.set(indexMap, r.selfIndex, record.selfIndex); + StringMapWrapper, + ListWrapper, + SetWrapper; + function isListLikeIterable(obj) { + if (!isJsObject(obj)) + return false; + return ListWrapper.isList(obj) || (!(obj instanceof Map) && Symbol.iterator in obj); + } + function iterateListLike(obj, fn) { + if (ListWrapper.isList(obj)) { + for (var i = 0; i < obj.length; i++) { + fn(obj[i]); + } + } else { + var iterator = obj[Symbol.iterator](); + var item; + while (!((item = iterator.next()).done)) { + fn(item.value); } } - return assert.returnType((res), assert.genericType(List, ProtoRecord)); - } - function _selfRecord(r, contextIndex, selfIndex) { - assert.argumentTypes(r, ProtoRecord, contextIndex, assert.type.number, selfIndex, assert.type.number); - return assert.returnType((new ProtoRecord(RECORD_TYPE_SELF, "self", null, [], r.fixedArgs, contextIndex, r.directiveIndex, selfIndex, r.bindingRecord, r.expressionAsString, r.lastInBinding, r.lastInDirective)), ProtoRecord); - } - function _findMatching(r, rs) { - return ListWrapper.find(rs, (function(rr) { - return rr.mode === r.mode && rr.funcOrValue === r.funcOrValue && rr.contextIndex === r.contextIndex && ListWrapper.equals(rr.args, r.args); - })); - } - function _replaceIndices(r, selfIndex, indexMap) { - var args = ListWrapper.map(r.args, (function(a) { - return _map(indexMap, a); - })); - var contextIndex = _map(indexMap, r.contextIndex); - return new ProtoRecord(r.mode, r.name, r.funcOrValue, args, r.fixedArgs, contextIndex, r.directiveIndex, selfIndex, r.bindingRecord, r.expressionAsString, r.lastInBinding, r.lastInDirective); - } - function _map(indexMap, value) { - assert.argumentTypes(indexMap, Map, value, assert.type.number); - var r = MapWrapper.get(indexMap, value); - return isPresent(r) ? r : value; } - $__export("coalesce", coalesce); - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - Map = $__m.Map; - MapWrapper = $__m.MapWrapper; - }, function($__m) { - RECORD_TYPE_SELF = $__m.RECORD_TYPE_SELF; - ProtoRecord = $__m.ProtoRecord; - }], - execute: function() { - Object.defineProperty(coalesce, "parameters", {get: function() { - return [[assert.genericType(List, ProtoRecord)]]; - }}); - Object.defineProperty(_selfRecord, "parameters", {get: function() { - return [[ProtoRecord], [assert.type.number], [assert.type.number]]; - }}); - Object.defineProperty(_findMatching, "parameters", {get: function() { - return [[ProtoRecord], [assert.genericType(List, ProtoRecord)]]; - }}); - Object.defineProperty(_replaceIndices, "parameters", {get: function() { - return [[ProtoRecord], [assert.type.number], [Map]]; - }}); - Object.defineProperty(_map, "parameters", {get: function() { - return [[Map], [assert.type.number]]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/pipes/iterable_changes", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/pipes/iterable_changes"; - var assert, - isListLikeIterable, - iterateListLike, - ListWrapper, - MapWrapper, - int, - isBlank, - isPresent, - stringify, - getMapKey, - looseIdentical, - WrappedValue, - Pipe, - IterableChangesFactory, - IterableChanges, - CollectionChangeRecord, - _DuplicateItemRecordList, - _DuplicateMap; + $__export("isListLikeIterable", isListLikeIterable); + $__export("iterateListLike", iterateListLike); return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isListLikeIterable = $__m.isListLikeIterable; - iterateListLike = $__m.iterateListLike; - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - }, function($__m) { - int = $__m.int; - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - stringify = $__m.stringify; - getMapKey = $__m.getMapKey; - looseIdentical = $__m.looseIdentical; - }, function($__m) { - WrappedValue = $__m.WrappedValue; - Pipe = $__m.Pipe; + isJsObject = $__m.isJsObject; + global = $__m.global; }], execute: function() { - IterableChangesFactory = (function() { - function IterableChangesFactory() {} - return ($traceurRuntime.createClass)(IterableChangesFactory, { - supports: function(obj) { - return assert.returnType((IterableChanges.supportsObj(obj)), assert.type.boolean); + __esModule = true; + $__export("__esModule", __esModule); + List = global.Array; + $__export("List", List); + Map = global.Map; + $__export("Map", Map); + Set = global.Set; + $__export("Set", Set); + StringMap = global.Object; + $__export("StringMap", StringMap); + createMapFromPairs = (function() { + try { + if (new Map([1, 2]).size === 2) { + return function createMapFromPairs(pairs) { + return new Map(pairs); + }; + } + } catch (e) {} + return function createMapAndPopulateFromPairs(pairs) { + var map = new Map(); + for (var i = 0; i < pairs.length; i++) { + var pair = pairs[i]; + map.set(pair[0], pair[1]); + } + return map; + }; + })(); + MapWrapper = (function() { + function MapWrapper() {} + return ($traceurRuntime.createClass)(MapWrapper, {}, { + create: function() { + return new Map(); + }, + clone: function(m) { + return new Map(m); + }, + createFromStringMap: function(stringMap) { + var result = MapWrapper.create(); + for (var prop in stringMap) { + MapWrapper.set(result, prop, stringMap[prop]); + } + return result; }, - create: function(cdRef) { - return assert.returnType((new IterableChanges()), Pipe); + createFromPairs: function(pairs) { + return createMapFromPairs(pairs); + }, + get: function(m, k) { + return m.get(k); + }, + set: function(m, k, v) { + m.set(k, v); + }, + contains: function(m, k) { + return m.has(k); + }, + forEach: function(m, fn) { + m.forEach(fn); + }, + size: function(m) { + return m.size; + }, + delete: function(m, k) { + m.delete(k); + }, + clear: function(m) { + m.clear(); + }, + clearValues: function(m) { + var keyIterator = m.keys(); + var k; + while (!((k = keyIterator.next()).done)) { + m.set(k.value, null); + } + }, + iterable: function(m) { + return m; + }, + keys: function(m) { + return m.keys(); + }, + values: function(m) { + return m.values(); } - }, {}); + }); }()); - $__export("IterableChangesFactory", IterableChangesFactory); - IterableChanges = (function($__super) { - function IterableChanges() { - $traceurRuntime.superConstructor(IterableChanges).call(this); - this._collection = null; - this._length = null; - this._linkedRecords = null; - this._unlinkedRecords = null; - this._previousItHead = null; - this._itHead = null; - this._itTail = null; - this._additionsHead = null; - this._additionsTail = null; - this._movesHead = null; - this._movesTail = null; - this._removalsHead = null; - this._removalsTail = null; - } - return ($traceurRuntime.createClass)(IterableChanges, { - supports: function(obj) { - return assert.returnType((IterableChanges.supportsObj(obj)), assert.type.boolean); + $__export("MapWrapper", MapWrapper); + StringMapWrapper = (function() { + function StringMapWrapper() {} + return ($traceurRuntime.createClass)(StringMapWrapper, {}, { + create: function() { + return {}; }, - get collection() { - return this._collection; + contains: function(map, key) { + return map.hasOwnProperty(key); }, - get length() { - return assert.returnType((this._length), int); + get: function(map, key) { + return map.hasOwnProperty(key) ? map[key] : undefined; }, - forEachItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._itHead; record !== null; record = record._next) { - fn(record); - } + set: function(map, key, value) { + map[key] = value; }, - forEachPreviousItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._previousItHead; record !== null; record = record._nextPrevious) { - fn(record); - } + keys: function(map) { + return Object.keys(map); }, - forEachAddedItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._additionsHead; record !== null; record = record._nextAdded) { - fn(record); + isEmpty: function(map) { + for (var prop in map) { + return false; } + return true; }, - forEachMovedItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._movesHead; record !== null; record = record._nextMoved) { - fn(record); - } + delete: function(map, key) { + delete map[key]; }, - forEachRemovedItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._removalsHead; record !== null; record = record._nextRemoved) { - fn(record); + forEach: function(map, callback) { + for (var prop in map) { + if (map.hasOwnProperty(prop)) { + callback(map[prop], prop); + } } }, - transform: function(collection) { - if (this.check(collection)) { - return WrappedValue.wrap(this); - } else { - return this; + merge: function(m1, m2) { + var m = {}; + for (var attr in m1) { + if (m1.hasOwnProperty(attr)) { + m[attr] = m1[attr]; + } + } + for (var attr in m2) { + if (m2.hasOwnProperty(attr)) { + m[attr] = m2[attr]; + } } + return m; }, - check: function(collection) { - var $__0 = this; - this._reset(); - var record = assert.type(this._itHead, CollectionChangeRecord); - var mayBeDirty = assert.type(false, assert.type.boolean); - var index; - var item; - if (ListWrapper.isList(collection)) { - var list = collection; - this._length = collection.length; - for (index = 0; index < this._length; index++) { - item = list[index]; - if (record === null || !looseIdentical(record.item, item)) { - record = this._mismatch(record, item, index); - mayBeDirty = true; - } else if (mayBeDirty) { - record = this._verifyReinsertion(record, item, index); - } - record = record._next; + equals: function(m1, m2) { + var k1 = Object.keys(m1); + var k2 = Object.keys(m2); + if (k1.length != k2.length) { + return false; + } + var key; + for (var i = 0; i < k1.length; i++) { + key = k1[i]; + if (m1[key] !== m2[key]) { + return false; } - } else { - index = 0; - iterateListLike(collection, (function(item) { - if (record === null || !looseIdentical(record.item, item)) { - record = $__0._mismatch(record, item, index); - mayBeDirty = true; - } else if (mayBeDirty) { - record = $__0._verifyReinsertion(record, item, index); - } - record = record._next; - index++; - })); - this._length = index; } - this._truncate(record); - this._collection = collection; - return assert.returnType((this.isDirty), assert.type.boolean); + return true; + } + }); + }()); + $__export("StringMapWrapper", StringMapWrapper); + ListWrapper = (function() { + function ListWrapper() {} + return ($traceurRuntime.createClass)(ListWrapper, {}, { + create: function() { + return new List(); }, - get isDirty() { - return assert.returnType((this._additionsHead !== null || this._movesHead !== null || this._removalsHead !== null), assert.type.boolean); + createFixedSize: function(size) { + return new List(size); }, - _reset: function() { - if (this.isDirty) { - var record; - var nextRecord; - for (record = this._previousItHead = this._itHead; record !== null; record = record._next) { - record._nextPrevious = record._next; - } - for (record = this._additionsHead; record !== null; record = record._nextAdded) { - record.previousIndex = record.currentIndex; - } - this._additionsHead = this._additionsTail = null; - for (record = this._movesHead; record !== null; record = nextRecord) { - record.previousIndex = record.currentIndex; - nextRecord = record._nextMoved; - } - this._movesHead = this._movesTail = null; - this._removalsHead = this._removalsTail = null; + get: function(m, k) { + return m[k]; + }, + set: function(m, k, v) { + m[k] = v; + }, + clone: function(array) { + return array.slice(0); + }, + map: function(array, fn) { + return array.map(fn); + }, + forEach: function(array, fn) { + for (var i = 0; i < array.length; i++) { + fn(array[i]); } }, - _mismatch: function(record, item, index) { - assert.argumentTypes(record, CollectionChangeRecord, item, assert.type.any, index, int); - var previousRecord; - if (record === null) { - previousRecord = this._itTail; - } else { - previousRecord = record._prev; - this._remove(record); + push: function(array, el) { + array.push(el); + }, + first: function(array) { + if (!array) + return null; + return array[0]; + }, + last: function(array) { + if (!array || array.length == 0) + return null; + return array[array.length - 1]; + }, + find: function(list, pred) { + for (var i = 0; i < list.length; ++i) { + if (pred(list[i])) + return list[i]; } - record = this._linkedRecords === null ? null : this._linkedRecords.get(item, index); - if (record !== null) { - this._moveAfter(record, previousRecord, index); - } else { - record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(item); - if (record !== null) { - this._reinsertAfter(record, previousRecord, index); - } else { - record = this._addAfter(new CollectionChangeRecord(item), previousRecord, index); - } + return null; + }, + indexOf: function(array, value) { + var startIndex = arguments[2] !== (void 0) ? arguments[2] : -1; + return array.indexOf(value, startIndex); + }, + reduce: function(list, fn, init) { + return list.reduce(fn, init); + }, + filter: function(array, pred) { + return array.filter(pred); + }, + any: function(list, pred) { + for (var i = 0; i < list.length; ++i) { + if (pred(list[i])) + return true; } - return assert.returnType((record), CollectionChangeRecord); + return false; }, - _verifyReinsertion: function(record, item, index) { - assert.argumentTypes(record, CollectionChangeRecord, item, assert.type.any, index, int); - var reinsertRecord = assert.type(this._unlinkedRecords === null ? null : this._unlinkedRecords.get(item), CollectionChangeRecord); - if (reinsertRecord !== null) { - record = this._reinsertAfter(reinsertRecord, record._prev, index); - } else if (record.currentIndex != index) { - record.currentIndex = index; - this._addToMoves(record, index); - } - return assert.returnType((record), CollectionChangeRecord); + contains: function(list, el) { + return list.indexOf(el) !== -1; }, - _truncate: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - while (record !== null) { - var nextRecord = assert.type(record._next, CollectionChangeRecord); - this._addToRemovals(this._unlink(record)); - record = nextRecord; - } - if (this._unlinkedRecords !== null) { - this._unlinkedRecords.clear(); - } - if (this._additionsTail !== null) { - this._additionsTail._nextAdded = null; - } - if (this._movesTail !== null) { - this._movesTail._nextMoved = null; - } - if (this._itTail !== null) { - this._itTail._next = null; - } - if (this._removalsTail !== null) { - this._removalsTail._nextRemoved = null; - } + reversed: function(array) { + var a = ListWrapper.clone(array); + return a.reverse(); }, - _reinsertAfter: function(record, prevRecord, index) { - assert.argumentTypes(record, CollectionChangeRecord, prevRecord, CollectionChangeRecord, index, int); - if (this._unlinkedRecords !== null) { - this._unlinkedRecords.remove(record); - } - var prev = record._prevRemoved; - var next = record._nextRemoved; - if (prev === null) { - this._removalsHead = next; - } else { - prev._nextRemoved = next; - } - if (next === null) { - this._removalsTail = prev; - } else { - next._prevRemoved = prev; - } - this._insertAfter(record, prevRecord, index); - this._addToMoves(record, index); - return assert.returnType((record), CollectionChangeRecord); + concat: function(a, b) { + return a.concat(b); }, - _moveAfter: function(record, prevRecord, index) { - assert.argumentTypes(record, CollectionChangeRecord, prevRecord, CollectionChangeRecord, index, int); - this._unlink(record); - this._insertAfter(record, prevRecord, index); - this._addToMoves(record, index); - return assert.returnType((record), CollectionChangeRecord); + isList: function(list) { + return Array.isArray(list); }, - _addAfter: function(record, prevRecord, index) { - assert.argumentTypes(record, CollectionChangeRecord, prevRecord, CollectionChangeRecord, index, int); - this._insertAfter(record, prevRecord, index); - if (this._additionsTail === null) { - this._additionsTail = this._additionsHead = record; - } else { - this._additionsTail = this._additionsTail._nextAdded = record; - } - return assert.returnType((record), CollectionChangeRecord); + insert: function(list, index, value) { + list.splice(index, 0, value); }, - _insertAfter: function(record, prevRecord, index) { - assert.argumentTypes(record, CollectionChangeRecord, prevRecord, CollectionChangeRecord, index, int); - var next = assert.type(prevRecord === null ? this._itHead : prevRecord._next, CollectionChangeRecord); - record._next = next; - record._prev = prevRecord; - if (next === null) { - this._itTail = record; - } else { - next._prev = record; - } - if (prevRecord === null) { - this._itHead = record; - } else { - prevRecord._next = record; - } - if (this._linkedRecords === null) { - this._linkedRecords = new _DuplicateMap(); + removeAt: function(list, index) { + var res = list[index]; + list.splice(index, 1); + return res; + }, + removeAll: function(list, items) { + for (var i = 0; i < items.length; ++i) { + var index = list.indexOf(items[i]); + list.splice(index, 1); } - this._linkedRecords.put(record); - record.currentIndex = index; - return assert.returnType((record), CollectionChangeRecord); }, - _remove: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - return assert.returnType((this._addToRemovals(this._unlink(record))), CollectionChangeRecord); + removeLast: function(list) { + return list.pop(); }, - _unlink: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - if (this._linkedRecords !== null) { - this._linkedRecords.remove(record); + remove: function(list, el) { + var index = list.indexOf(el); + if (index > -1) { + list.splice(index, 1); + return true; } - var prev = record._prev; - var next = record._next; - if (prev === null) { - this._itHead = next; - } else { - prev._next = next; + return false; + }, + clear: function(list) { + list.splice(0, list.length); + }, + join: function(list, s) { + return list.join(s); + }, + isEmpty: function(list) { + return list.length == 0; + }, + fill: function(list, value) { + var start = arguments[2] !== (void 0) ? arguments[2] : 0; + var end = arguments[3] !== (void 0) ? arguments[3] : null; + list.fill(value, start, end === null ? undefined : end); + }, + equals: function(a, b) { + if (a.length != b.length) + return false; + for (var i = 0; i < a.length; ++i) { + if (a[i] !== b[i]) + return false; } - if (next === null) { - this._itTail = prev; - } else { - next._prev = prev; + return true; + }, + slice: function(l) { + var from = arguments[1] !== (void 0) ? arguments[1] : 0; + var to = arguments[2] !== (void 0) ? arguments[2] : null; + return l.slice(from, to === null ? undefined : to); + }, + splice: function(l, from, length) { + return l.splice(from, length); + }, + sort: function(l, compareFn) { + l.sort(compareFn); + } + }); + }()); + $__export("ListWrapper", ListWrapper); + SetWrapper = (function() { + function SetWrapper() {} + return ($traceurRuntime.createClass)(SetWrapper, {}, { + createFromList: function(lst) { + return new Set(lst); + }, + has: function(s, key) { + return s.has(key); + } + }); + }()); + $__export("SetWrapper", SetWrapper); + } + }; +}); + +System.register("angular2/src/di/annotations_impl", ["angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/di/annotations_impl"; + var __decorate, + __metadata, + CONST, + __esModule, + Inject, + InjectPromise, + InjectLazy, + Optional, + DependencyAnnotation, + Injectable; + return { + setters: [function($__m) { + CONST = $__m.CONST; + }], + execute: function() { + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + Inject = (($traceurRuntime.createClass)(function(token) { + this.token = token; + }, {}, {})); + $__export("Inject", Inject); + $__export("Inject", Inject = __decorate([CONST(), __metadata('design:paramtypes', [Object])], Inject)); + InjectPromise = (($traceurRuntime.createClass)(function(token) { + this.token = token; + }, {}, {})); + $__export("InjectPromise", InjectPromise); + $__export("InjectPromise", InjectPromise = __decorate([CONST(), __metadata('design:paramtypes', [Object])], InjectPromise)); + InjectLazy = (($traceurRuntime.createClass)(function(token) { + this.token = token; + }, {}, {})); + $__export("InjectLazy", InjectLazy); + $__export("InjectLazy", InjectLazy = __decorate([CONST(), __metadata('design:paramtypes', [Object])], InjectLazy)); + Optional = (($traceurRuntime.createClass)(function() {}, {}, {})); + $__export("Optional", Optional); + $__export("Optional", Optional = __decorate([CONST(), __metadata('design:paramtypes', [])], Optional)); + DependencyAnnotation = (($traceurRuntime.createClass)(function() {}, {get token() { + return null; + }}, {})); + $__export("DependencyAnnotation", DependencyAnnotation); + $__export("DependencyAnnotation", DependencyAnnotation = __decorate([CONST(), __metadata('design:paramtypes', [])], DependencyAnnotation)); + Injectable = (($traceurRuntime.createClass)(function() {}, {}, {})); + $__export("Injectable", Injectable); + $__export("Injectable", Injectable = __decorate([CONST(), __metadata('design:paramtypes', [])], Injectable)); + } + }; +}); + +System.register("angular2/src/util/decorators", ["angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/util/decorators"; + var __esModule, + global; + function makeDecorator(annotationCls) { + return function() { + var args = arguments; + var Reflect = global.Reflect; + if (!(Reflect && Reflect.getMetadata)) { + throw 'reflect-metadata shim is required when using class decorators'; + } + var annotationInstance = Object.create(annotationCls.prototype); + annotationCls.apply(annotationInstance, args); + return function(cls) { + var annotations = Reflect.getMetadata('annotations', cls); + annotations = annotations || []; + annotations.push(annotationInstance); + Reflect.defineMetadata('annotations', annotations, cls); + return cls; + }; + }; + } + function makeParamDecorator(annotationCls) { + return function() { + var args = arguments; + var Reflect = global.Reflect; + if (!(Reflect && Reflect.getMetadata)) { + throw 'reflect-metadata shim is required when using parameter decorators'; + } + var annotationInstance = Object.create(annotationCls.prototype); + annotationCls.apply(annotationInstance, args); + return function(cls, unusedKey, index) { + var parameters = Reflect.getMetadata('parameters', cls); + parameters = parameters || []; + while (parameters.length <= index) { + parameters.push(null); + } + parameters[index] = annotationInstance; + Reflect.defineMetadata('parameters', parameters, cls); + return cls; + }; + }; + } + $__export("makeDecorator", makeDecorator); + $__export("makeParamDecorator", makeParamDecorator); + return { + setters: [function($__m) { + global = $__m.global; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + } + }; +}); + +System.register("angular2/src/reflection/types", [], function($__export) { + "use strict"; + var __moduleName = "angular2/src/reflection/types"; + var __esModule; + return { + setters: [], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + $__export("SetterFn", Function); + $__export("GetterFn", Function); + $__export("MethodFn", Function); + } + }; +}); + +System.register("angular2/src/reflection/reflection_capabilities", ["angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/reflection/reflection_capabilities"; + var isPresent, + global, + ListWrapper, + __esModule, + ReflectionCapabilities; + return { + setters: [function($__m) { + isPresent = $__m.isPresent; + global = $__m.global; + }, function($__m) { + ListWrapper = $__m.ListWrapper; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + ReflectionCapabilities = (function() { + function ReflectionCapabilities(reflect) { + this._reflect = isPresent(reflect) ? reflect : global.Reflect; + } + return ($traceurRuntime.createClass)(ReflectionCapabilities, { + factory: function(t) { + switch (t.length) { + case 0: + return function() { + return new t(); + }; + case 1: + return function(a1) { + return new t(a1); + }; + case 2: + return function(a1, a2) { + return new t(a1, a2); + }; + case 3: + return function(a1, a2, a3) { + return new t(a1, a2, a3); + }; + case 4: + return function(a1, a2, a3, a4) { + return new t(a1, a2, a3, a4); + }; + case 5: + return function(a1, a2, a3, a4, a5) { + return new t(a1, a2, a3, a4, a5); + }; + case 6: + return function(a1, a2, a3, a4, a5, a6) { + return new t(a1, a2, a3, a4, a5, a6); + }; + case 7: + return function(a1, a2, a3, a4, a5, a6, a7) { + return new t(a1, a2, a3, a4, a5, a6, a7); + }; + case 8: + return function(a1, a2, a3, a4, a5, a6, a7, a8) { + return new t(a1, a2, a3, a4, a5, a6, a7, a8); + }; + case 9: + return function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9); + }; + case 10: + return function(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10) { + return new t(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10); + }; } - return assert.returnType((record), CollectionChangeRecord); + ; + throw new Error("Factory cannot take more than 10 arguments"); }, - _addToMoves: function(record, toIndex) { - assert.argumentTypes(record, CollectionChangeRecord, toIndex, int); - if (record.previousIndex === toIndex) { - return assert.returnType((record), CollectionChangeRecord); + _zipTypesAndAnnotaions: function(paramTypes, paramAnnotations) { + var result = ListWrapper.createFixedSize(paramTypes.length); + for (var i = 0; i < result.length; i++) { + if (paramTypes[i] != Object) { + result[i] = [paramTypes[i]]; + } else { + result[i] = []; + } + if (isPresent(paramAnnotations) && isPresent(paramAnnotations[i])) { + result[i] = result[i].concat(paramAnnotations[i]); + } } - if (this._movesTail === null) { - this._movesTail = this._movesHead = record; - } else { - this._movesTail = this._movesTail._nextMoved = record; + return result; + }, + parameters: function(typeOfFunc) { + if (isPresent(typeOfFunc.parameters)) { + return typeOfFunc.parameters; + } + if (isPresent(this._reflect) && isPresent(this._reflect.getMetadata)) { + var paramAnnotations = this._reflect.getMetadata('parameters', typeOfFunc); + var paramTypes = this._reflect.getMetadata('design:paramtypes', typeOfFunc); + if (isPresent(paramTypes) || isPresent(paramAnnotations)) { + return this._zipTypesAndAnnotaions(paramTypes, paramAnnotations); + } } - return assert.returnType((record), CollectionChangeRecord); + return ListWrapper.createFixedSize(typeOfFunc.length); }, - _addToRemovals: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - if (this._unlinkedRecords === null) { - this._unlinkedRecords = new _DuplicateMap(); + annotations: function(typeOfFunc) { + if (isPresent(typeOfFunc.annotations)) { + return typeOfFunc.annotations; } - this._unlinkedRecords.put(record); - record.currentIndex = null; - record._nextRemoved = null; - if (this._removalsTail === null) { - this._removalsTail = this._removalsHead = record; - record._prevRemoved = null; - } else { - record._prevRemoved = this._removalsTail; - this._removalsTail = this._removalsTail._nextRemoved = record; + if (isPresent(this._reflect) && isPresent(this._reflect.getMetadata)) { + var annotations = this._reflect.getMetadata('annotations', typeOfFunc); + if (isPresent(annotations)) + return annotations; } - return assert.returnType((record), CollectionChangeRecord); + return []; }, - toString: function() { - var record; - var list = []; - for (record = this._itHead; record !== null; record = record._next) { - ListWrapper.push(list, record); + getter: function(name) { + return new Function('o', 'return o.' + name + ';'); + }, + setter: function(name) { + return new Function('o', 'v', 'return o.' + name + ' = v;'); + }, + method: function(name) { + var functionBody = ("if (!o." + name + ") throw new Error('\"" + name + "\" is undefined');\n return o." + name + ".apply(o, args);"); + return new Function('o', 'args', functionBody); + } + }, {}); + }()); + $__export("ReflectionCapabilities", ReflectionCapabilities); + } + }; +}); + +System.register("angular2/src/change_detection/parser/locals", ["angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/parser/locals"; + var isPresent, + BaseException, + MapWrapper, + __esModule, + Locals; + return { + setters: [function($__m) { + isPresent = $__m.isPresent; + BaseException = $__m.BaseException; + }, function($__m) { + MapWrapper = $__m.MapWrapper; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + Locals = (function() { + function Locals(parent, current) { + this.parent = parent; + this.current = current; + } + return ($traceurRuntime.createClass)(Locals, { + contains: function(name) { + if (MapWrapper.contains(this.current, name)) { + return true; } - var previous = []; - for (record = this._previousItHead; record !== null; record = record._nextPrevious) { - ListWrapper.push(previous, record); + if (isPresent(this.parent)) { + return this.parent.contains(name); } - var additions = []; - for (record = this._additionsHead; record !== null; record = record._nextAdded) { - ListWrapper.push(additions, record); + return false; + }, + get: function(name) { + if (MapWrapper.contains(this.current, name)) { + return MapWrapper.get(this.current, name); } - var moves = []; - for (record = this._movesHead; record !== null; record = record._nextMoved) { - ListWrapper.push(moves, record); + if (isPresent(this.parent)) { + return this.parent.get(name); } - var removals = []; - for (record = this._removalsHead; record !== null; record = record._nextRemoved) { - ListWrapper.push(removals, record); + throw new BaseException(("Cannot find '" + name + "'")); + }, + set: function(name, value) { + if (MapWrapper.contains(this.current, name)) { + MapWrapper.set(this.current, name, value); + } else { + throw new BaseException('Setting of new keys post-construction is not supported.'); } - return assert.returnType(("collection: " + list.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" + "additions: " + additions.join(', ') + "\n" + "moves: " + moves.join(', ') + "\n" + "removals: " + removals.join(', ') + "\n"), assert.type.string); + }, + clearValues: function() { + MapWrapper.clearValues(this.current); } - }, {supportsObj: function(obj) { - return assert.returnType((isListLikeIterable(obj)), assert.type.boolean); - }}, $__super); - }(Pipe)); - $__export("IterableChanges", IterableChanges); - Object.defineProperty(IterableChanges.prototype.forEachItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(IterableChanges.prototype.forEachPreviousItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(IterableChanges.prototype.forEachAddedItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(IterableChanges.prototype.forEachMovedItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(IterableChanges.prototype.forEachRemovedItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(IterableChanges.prototype._mismatch, "parameters", {get: function() { - return [[CollectionChangeRecord], [], [int]]; - }}); - Object.defineProperty(IterableChanges.prototype._verifyReinsertion, "parameters", {get: function() { - return [[CollectionChangeRecord], [], [int]]; - }}); - Object.defineProperty(IterableChanges.prototype._truncate, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); - Object.defineProperty(IterableChanges.prototype._reinsertAfter, "parameters", {get: function() { - return [[CollectionChangeRecord], [CollectionChangeRecord], [int]]; - }}); - Object.defineProperty(IterableChanges.prototype._moveAfter, "parameters", {get: function() { - return [[CollectionChangeRecord], [CollectionChangeRecord], [int]]; - }}); - Object.defineProperty(IterableChanges.prototype._addAfter, "parameters", {get: function() { - return [[CollectionChangeRecord], [CollectionChangeRecord], [int]]; - }}); - Object.defineProperty(IterableChanges.prototype._insertAfter, "parameters", {get: function() { - return [[CollectionChangeRecord], [CollectionChangeRecord], [int]]; - }}); - Object.defineProperty(IterableChanges.prototype._remove, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); - Object.defineProperty(IterableChanges.prototype._unlink, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); - Object.defineProperty(IterableChanges.prototype._addToMoves, "parameters", {get: function() { - return [[CollectionChangeRecord], [int]]; - }}); - Object.defineProperty(IterableChanges.prototype._addToRemovals, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); - CollectionChangeRecord = (function() { - function CollectionChangeRecord(item) { - this.currentIndex = null; - this.previousIndex = null; - this.item = item; - this._nextPrevious = null; - this._prev = null; - this._next = null; - this._prevDup = null; - this._nextDup = null; - this._prevRemoved = null; - this._nextRemoved = null; - this._nextAdded = null; - this._nextMoved = null; - } - return ($traceurRuntime.createClass)(CollectionChangeRecord, {toString: function() { - return assert.returnType((this.previousIndex === this.currentIndex ? stringify(this.item) : stringify(this.item) + '[' + stringify(this.previousIndex) + '->' + stringify(this.currentIndex) + ']'), assert.type.string); - }}, {}); + }, {}); }()); - $__export("CollectionChangeRecord", CollectionChangeRecord); - _DuplicateItemRecordList = (function() { - function _DuplicateItemRecordList() { - this._head = null; - this._tail = null; + $__export("Locals", Locals); + } + }; +}); + +System.register("angular2/src/change_detection/exceptions", ["angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/exceptions"; + var BaseException, + __esModule, + ExpressionChangedAfterItHasBeenChecked, + ChangeDetectionError; + return { + setters: [function($__m) { + BaseException = $__m.BaseException; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + ExpressionChangedAfterItHasBeenChecked = (function($__super) { + function ExpressionChangedAfterItHasBeenChecked(proto, change) { + $traceurRuntime.superConstructor(ExpressionChangedAfterItHasBeenChecked).call(this); + this.message = ("Expression '" + proto.expressionAsString + "' has changed after it was checked. ") + ("Previous value: '" + change.previousValue + "'. Current value: '" + change.currentValue + "'"); } - return ($traceurRuntime.createClass)(_DuplicateItemRecordList, { - add: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - if (this._head === null) { - this._head = this._tail = record; - record._nextDup = null; - record._prevDup = null; - } else { - this._tail._nextDup = record; - record._prevDup = this._tail; - record._nextDup = null; - this._tail = record; - } - }, - get: function(item, afterIndex) { - assert.argumentTypes(item, assert.type.any, afterIndex, int); - var record; - for (record = this._head; record !== null; record = record._nextDup) { - if ((afterIndex === null || afterIndex < record.currentIndex) && looseIdentical(record.item, item)) { - return assert.returnType((record), CollectionChangeRecord); - } - } - return assert.returnType((null), CollectionChangeRecord); + return ($traceurRuntime.createClass)(ExpressionChangedAfterItHasBeenChecked, {toString: function() { + return this.message; + }}, {}, $__super); + }(BaseException)); + $__export("ExpressionChangedAfterItHasBeenChecked", ExpressionChangedAfterItHasBeenChecked); + ChangeDetectionError = (function($__super) { + function ChangeDetectionError(proto, originalException) { + $traceurRuntime.superConstructor(ChangeDetectionError).call(this); + this.originalException = originalException; + this.location = proto.expressionAsString; + this.message = (this.originalException + " in [" + this.location + "]"); + } + return ($traceurRuntime.createClass)(ChangeDetectionError, {toString: function() { + return this.message; + }}, {}, $__super); + }(BaseException)); + $__export("ChangeDetectionError", ChangeDetectionError); + } + }; +}); + +System.register("angular2/src/change_detection/constants", [], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/constants"; + var __esModule, + CHECK_ONCE, + CHECKED, + CHECK_ALWAYS, + DETACHED, + ON_PUSH, + DEFAULT; + return { + setters: [], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + CHECK_ONCE = "CHECK_ONCE"; + $__export("CHECK_ONCE", CHECK_ONCE); + CHECKED = "CHECKED"; + $__export("CHECKED", CHECKED); + CHECK_ALWAYS = "ALWAYS_CHECK"; + $__export("CHECK_ALWAYS", CHECK_ALWAYS); + DETACHED = "DETACHED"; + $__export("DETACHED", DETACHED); + ON_PUSH = "ON_PUSH"; + $__export("ON_PUSH", ON_PUSH); + DEFAULT = "DEFAULT"; + $__export("DEFAULT", DEFAULT); + } + }; +}); + +System.register("angular2/src/change_detection/pipes/pipe", ["angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/pipes/pipe"; + var __decorate, + __metadata, + BaseException, + CONST, + __esModule, + WrappedValue, + _wrappedValues, + _wrappedIndex, + Pipe, + PipeFactory; + function _abstract() { + throw new BaseException('This method is abstract'); + } + return { + setters: [function($__m) { + BaseException = $__m.BaseException; + CONST = $__m.CONST; + }], + execute: function() { + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + WrappedValue = (function() { + function WrappedValue(wrapped) { + this.wrapped = wrapped; + } + return ($traceurRuntime.createClass)(WrappedValue, {}, {wrap: function(value) { + var w = _wrappedValues[_wrappedIndex++ % 5]; + w.wrapped = value; + return w; + }}); + }()); + $__export("WrappedValue", WrappedValue); + _wrappedValues = [new WrappedValue(null), new WrappedValue(null), new WrappedValue(null), new WrappedValue(null), new WrappedValue(null)]; + _wrappedIndex = 0; + Pipe = (function() { + function Pipe() {} + return ($traceurRuntime.createClass)(Pipe, { + supports: function(obj) { + return false; }, - remove: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - var prev = assert.type(record._prevDup, CollectionChangeRecord); - var next = assert.type(record._nextDup, CollectionChangeRecord); - if (prev === null) { - this._head = next; - } else { - prev._nextDup = next; - } - if (next === null) { - this._tail = prev; - } else { - next._prevDup = prev; - } - return assert.returnType((this._head === null), assert.type.boolean); + onDestroy: function() {}, + transform: function(value) { + return null; } }, {}); }()); - Object.defineProperty(_DuplicateItemRecordList.prototype.add, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); - Object.defineProperty(_DuplicateItemRecordList.prototype.get, "parameters", {get: function() { - return [[], [int]]; - }}); - Object.defineProperty(_DuplicateItemRecordList.prototype.remove, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); - _DuplicateMap = (function() { - function _DuplicateMap() { - this.map = MapWrapper.create(); + $__export("Pipe", Pipe); + PipeFactory = (($traceurRuntime.createClass)(function() {}, { + supports: function(obs) { + _abstract(); + return false; + }, + create: function(cdRef) { + _abstract(); + return null; } - return ($traceurRuntime.createClass)(_DuplicateMap, { - put: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - var key = getMapKey(record.item); - var duplicates = MapWrapper.get(this.map, key); - if (!isPresent(duplicates)) { - duplicates = new _DuplicateItemRecordList(); - MapWrapper.set(this.map, key, duplicates); - } - duplicates.add(record); - }, - get: function(value) { - var afterIndex = arguments[1] !== (void 0) ? arguments[1] : null; - var key = getMapKey(value); - var recordList = MapWrapper.get(this.map, key); - return assert.returnType((isBlank(recordList) ? null : recordList.get(value, afterIndex)), CollectionChangeRecord); - }, - remove: function(record) { - assert.argumentTypes(record, CollectionChangeRecord); - var key = getMapKey(record.item); - var recordList = assert.type(MapWrapper.get(this.map, key), _DuplicateItemRecordList); - if (recordList.remove(record)) { - MapWrapper.delete(this.map, key); - } - return assert.returnType((record), CollectionChangeRecord); - }, - get isEmpty() { - return assert.returnType((MapWrapper.size(this.map) === 0), assert.type.boolean); + }, {})); + $__export("PipeFactory", PipeFactory); + $__export("PipeFactory", PipeFactory = __decorate([CONST(), __metadata('design:paramtypes', [])], PipeFactory)); + } + }; +}); + +System.register("angular2/src/change_detection/change_detector_ref", ["angular2/src/change_detection/constants"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/change_detector_ref"; + var DETACHED, + CHECK_ALWAYS, + __esModule, + ChangeDetectorRef; + return { + setters: [function($__m) { + DETACHED = $__m.DETACHED; + CHECK_ALWAYS = $__m.CHECK_ALWAYS; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + ChangeDetectorRef = (function() { + function ChangeDetectorRef(_cd) { + this._cd = _cd; + } + return ($traceurRuntime.createClass)(ChangeDetectorRef, { + requestCheck: function() { + this._cd.markPathToRootAsCheckOnce(); }, - clear: function() { - MapWrapper.clear(this.map); + detach: function() { + this._cd.mode = DETACHED; }, - toString: function() { - return assert.returnType(('_DuplicateMap(' + stringify(this.map) + ')'), assert.type.string); + reattach: function() { + this._cd.mode = CHECK_ALWAYS; + this.requestCheck(); } }, {}); }()); - Object.defineProperty(_DuplicateMap.prototype.put, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); - Object.defineProperty(_DuplicateMap.prototype.remove, "parameters", {get: function() { - return [[CollectionChangeRecord]]; - }}); + $__export("ChangeDetectorRef", ChangeDetectorRef); } }; }); -System.register("angular2/src/change_detection/pipes/keyvalue_changes", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe"], function($__export) { +System.register("angular2/src/change_detection/proto_record", [], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/pipes/keyvalue_changes"; - var assert, - ListWrapper, - MapWrapper, - StringMapWrapper, - stringify, - looseIdentical, - isJsObject, - WrappedValue, - Pipe, - KeyValueChangesFactory, - KeyValueChanges, - KVChangeRecord; + var __moduleName = "angular2/src/change_detection/proto_record"; + var __esModule, + RECORD_TYPE_SELF, + RECORD_TYPE_CONST, + RECORD_TYPE_PRIMITIVE_OP, + RECORD_TYPE_PROPERTY, + RECORD_TYPE_LOCAL, + RECORD_TYPE_INVOKE_METHOD, + RECORD_TYPE_INVOKE_CLOSURE, + RECORD_TYPE_KEYED_ACCESS, + RECORD_TYPE_PIPE, + RECORD_TYPE_BINDING_PIPE, + RECORD_TYPE_INTERPOLATE, + ProtoRecord; + return { + setters: [], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + RECORD_TYPE_SELF = 0; + $__export("RECORD_TYPE_SELF", RECORD_TYPE_SELF); + RECORD_TYPE_CONST = 1; + $__export("RECORD_TYPE_CONST", RECORD_TYPE_CONST); + RECORD_TYPE_PRIMITIVE_OP = 2; + $__export("RECORD_TYPE_PRIMITIVE_OP", RECORD_TYPE_PRIMITIVE_OP); + RECORD_TYPE_PROPERTY = 3; + $__export("RECORD_TYPE_PROPERTY", RECORD_TYPE_PROPERTY); + RECORD_TYPE_LOCAL = 4; + $__export("RECORD_TYPE_LOCAL", RECORD_TYPE_LOCAL); + RECORD_TYPE_INVOKE_METHOD = 5; + $__export("RECORD_TYPE_INVOKE_METHOD", RECORD_TYPE_INVOKE_METHOD); + RECORD_TYPE_INVOKE_CLOSURE = 6; + $__export("RECORD_TYPE_INVOKE_CLOSURE", RECORD_TYPE_INVOKE_CLOSURE); + RECORD_TYPE_KEYED_ACCESS = 7; + $__export("RECORD_TYPE_KEYED_ACCESS", RECORD_TYPE_KEYED_ACCESS); + RECORD_TYPE_PIPE = 8; + $__export("RECORD_TYPE_PIPE", RECORD_TYPE_PIPE); + RECORD_TYPE_BINDING_PIPE = 9; + $__export("RECORD_TYPE_BINDING_PIPE", RECORD_TYPE_BINDING_PIPE); + RECORD_TYPE_INTERPOLATE = 10; + $__export("RECORD_TYPE_INTERPOLATE", RECORD_TYPE_INTERPOLATE); + ProtoRecord = (function() { + function ProtoRecord(mode, name, funcOrValue, args, fixedArgs, contextIndex, directiveIndex, selfIndex, bindingRecord, expressionAsString, lastInBinding, lastInDirective) { + this.mode = mode; + this.name = name; + this.funcOrValue = funcOrValue; + this.args = args; + this.fixedArgs = fixedArgs; + this.contextIndex = contextIndex; + this.directiveIndex = directiveIndex; + this.selfIndex = selfIndex; + this.bindingRecord = bindingRecord; + this.expressionAsString = expressionAsString; + this.lastInBinding = lastInBinding; + this.lastInDirective = lastInDirective; + } + return ($traceurRuntime.createClass)(ProtoRecord, {isPureFunction: function() { + return this.mode === RECORD_TYPE_INTERPOLATE || this.mode === RECORD_TYPE_PRIMITIVE_OP; + }}, {}); + }()); + $__export("ProtoRecord", ProtoRecord); + } + }; +}); + +System.register("angular2/src/change_detection/change_detection_jit_generator", ["angular2/src/facade/lang", "angular2/src/change_detection/abstract_change_detector", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/proto_record"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/change_detection_jit_generator"; + var BaseException, + AbstractChangeDetector, + ChangeDetectionUtil, + RECORD_TYPE_SELF, + RECORD_TYPE_PROPERTY, + RECORD_TYPE_LOCAL, + RECORD_TYPE_INVOKE_METHOD, + RECORD_TYPE_CONST, + RECORD_TYPE_INVOKE_CLOSURE, + RECORD_TYPE_PRIMITIVE_OP, + RECORD_TYPE_KEYED_ACCESS, + RECORD_TYPE_PIPE, + RECORD_TYPE_BINDING_PIPE, + RECORD_TYPE_INTERPOLATE, + __esModule, + ABSTRACT_CHANGE_DETECTOR, + UTIL, + DISPATCHER_ACCESSOR, + PIPE_REGISTRY_ACCESSOR, + PROTOS_ACCESSOR, + DIRECTIVES_ACCESSOR, + CONTEXT_ACCESSOR, + IS_CHANGED_LOCAL, + CHANGES_LOCAL, + LOCALS_ACCESSOR, + MODE_ACCESSOR, + TEMP_LOCAL, + CURRENT_PROTO, + ChangeDetectorJITGenerator; + function typeTemplate(type, cons, detectChanges, notifyOnAllChangesDone, setContext) { + return ("\n" + cons + "\n" + detectChanges + "\n" + notifyOnAllChangesDone + "\n" + setContext + ";\n\nreturn function(dispatcher, pipeRegistry) {\n return new " + type + "(dispatcher, pipeRegistry, protos, directiveRecords);\n}\n"); + } + function constructorTemplate(type, fieldsDefinitions) { + return ("\nvar " + type + " = function " + type + "(dispatcher, pipeRegistry, protos, directiveRecords) {\n" + ABSTRACT_CHANGE_DETECTOR + ".call(this);\n" + DISPATCHER_ACCESSOR + " = dispatcher;\n" + PIPE_REGISTRY_ACCESSOR + " = pipeRegistry;\n" + PROTOS_ACCESSOR + " = protos;\n" + DIRECTIVES_ACCESSOR + " = directiveRecords;\n" + LOCALS_ACCESSOR + " = null;\n" + fieldsDefinitions + "\n}\n\n" + type + ".prototype = Object.create(" + ABSTRACT_CHANGE_DETECTOR + ".prototype);\n"); + } + function pipeOnDestroyTemplate(pipeNames) { + return pipeNames.map((function(p) { + return (p + ".onDestroy()"); + })).join("\n"); + } + function hydrateTemplate(type, mode, fieldDefinitions, pipeOnDestroy, directiveFieldNames, detectorFieldNames) { + var directiveInit = ""; + for (var i = 0; i < directiveFieldNames.length; ++i) { + directiveInit += (directiveFieldNames[i] + " = directives.getDirectiveFor(this.directiveRecords[" + i + "].directiveIndex);\n"); + } + var detectorInit = ""; + for (var i = 0; i < detectorFieldNames.length; ++i) { + detectorInit += (detectorFieldNames[i] + " = directives.getDetectorFor(this.directiveRecords[" + i + "].directiveIndex);\n"); + } + return ("\n" + type + ".prototype.hydrate = function(context, locals, directives) {\n " + MODE_ACCESSOR + " = \"" + mode + "\";\n " + CONTEXT_ACCESSOR + " = context;\n " + LOCALS_ACCESSOR + " = locals;\n " + directiveInit + "\n " + detectorInit + "\n}\n" + type + ".prototype.dehydrate = function() {\n " + pipeOnDestroy + "\n " + fieldDefinitions + "\n " + LOCALS_ACCESSOR + " = null;\n}\n" + type + ".prototype.hydrated = function() {\n return " + CONTEXT_ACCESSOR + " !== " + UTIL + ".unitialized();\n}\n"); + } + function detectChangesTemplate(type, body) { + return ("\n" + type + ".prototype.detectChangesInRecords = function(throwOnChange) {\n " + body + "\n}\n"); + } + function callOnAllChangesDoneTemplate(type, body) { + return ("\n" + type + ".prototype.callOnAllChangesDone = function() {\n " + body + "\n}\n"); + } + function onAllChangesDoneTemplate(directive) { + return (directive + ".onAllChangesDone();"); + } + function detectChangesBodyTemplate(localDefinitions, changeDefinitions, records) { + return ("\n" + localDefinitions + "\n" + changeDefinitions + "\nvar " + TEMP_LOCAL + ";\nvar " + IS_CHANGED_LOCAL + " = false;\nvar " + CURRENT_PROTO + ";\nvar " + CHANGES_LOCAL + " = null;\n\ncontext = " + CONTEXT_ACCESSOR + ";\n" + records + "\n"); + } + function pipeCheckTemplate(protoIndex, context, bindingPropagationConfig, pipe, pipeType, oldValue, newValue, change, update, addToChanges, lastInDirective) { + return ("\n" + CURRENT_PROTO + " = " + PROTOS_ACCESSOR + "[" + protoIndex + "];\nif (" + pipe + " === " + UTIL + ".unitialized()) {\n " + pipe + " = " + PIPE_REGISTRY_ACCESSOR + ".get('" + pipeType + "', " + context + ", " + bindingPropagationConfig + ");\n} else if (!" + pipe + ".supports(" + context + ")) {\n " + pipe + ".onDestroy();\n " + pipe + " = " + PIPE_REGISTRY_ACCESSOR + ".get('" + pipeType + "', " + context + ", " + bindingPropagationConfig + ");\n}\n\n" + newValue + " = " + pipe + ".transform(" + context + ");\nif (" + oldValue + " !== " + newValue + ") {\n " + newValue + " = " + UTIL + ".unwrapValue(" + newValue + ");\n " + change + " = true;\n " + update + "\n " + addToChanges + "\n " + oldValue + " = " + newValue + ";\n}\n" + lastInDirective + "\n"); + } + function referenceCheckTemplate(protoIndex, assignment, oldValue, newValue, change, update, addToChanges, lastInDirective) { + return ("\n" + CURRENT_PROTO + " = " + PROTOS_ACCESSOR + "[" + protoIndex + "];\n" + assignment + "\nif (" + newValue + " !== " + oldValue + " || (" + newValue + " !== " + newValue + ") && (" + oldValue + " !== " + oldValue + ")) {\n " + change + " = true;\n " + update + "\n " + addToChanges + "\n " + oldValue + " = " + newValue + ";\n}\n" + lastInDirective + "\n"); + } + function assignmentTemplate(field, value) { + return (field + " = " + value + ";"); + } + function localDefinitionsTemplate(names) { + return names.map((function(n) { + return ("var " + n + ";"); + })).join("\n"); + } + function changeDefinitionsTemplate(names) { + return names.map((function(n) { + return ("var " + n + " = false;"); + })).join("\n"); + } + function fieldDefinitionsTemplate(names) { + return names.map((function(n) { + return (n + " = " + UTIL + ".unitialized();"); + })).join("\n"); + } + function ifChangedGuardTemplate(changeNames, body) { + var cond = changeNames.join(" || "); + return ("\nif (" + cond + ") {\n " + body + "\n}\n"); + } + function addToChangesTemplate(oldValue, newValue) { + return (CHANGES_LOCAL + " = " + UTIL + ".addChange(" + CHANGES_LOCAL + ", " + CURRENT_PROTO + ".bindingRecord.propertyName, " + UTIL + ".simpleChange(" + oldValue + ", " + newValue + "));"); + } + function updateDirectiveTemplate(oldValue, newValue, directiveProperty) { + return ("\nif(throwOnChange) " + UTIL + ".throwOnChange(" + CURRENT_PROTO + ", " + UTIL + ".simpleChange(" + oldValue + ", " + newValue + "));\n" + directiveProperty + " = " + newValue + ";\n" + IS_CHANGED_LOCAL + " = true;\n "); + } + function updateElementTemplate(oldValue, newValue) { + return ("\nif(throwOnChange) " + UTIL + ".throwOnChange(" + CURRENT_PROTO + ", " + UTIL + ".simpleChange(" + oldValue + ", " + newValue + "));\n" + DISPATCHER_ACCESSOR + ".notifyOnBinding(" + CURRENT_PROTO + ".bindingRecord, " + newValue + ");\n "); + } + function notifyOnChangesTemplate(directive) { + return ("\nif(" + CHANGES_LOCAL + ") {\n " + directive + ".onChange(" + CHANGES_LOCAL + ");\n " + CHANGES_LOCAL + " = null;\n}\n"); + } + function notifyOnPushDetectorsTemplate(detector) { + return ("\nif(" + IS_CHANGED_LOCAL + ") {\n " + detector + ".markAsCheckOnce();\n}\n"); + } + function lastInDirectiveTemplate(notifyOnChanges, notifyOnPush) { + return ("\n" + notifyOnChanges + "\n" + notifyOnPush + "\n" + IS_CHANGED_LOCAL + " = false;\n"); + } return { setters: [function($__m) { - assert = $__m.assert; + BaseException = $__m.BaseException; }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - StringMapWrapper = $__m.StringMapWrapper; + AbstractChangeDetector = $__m.AbstractChangeDetector; }, function($__m) { - stringify = $__m.stringify; - looseIdentical = $__m.looseIdentical; - isJsObject = $__m.isJsObject; + ChangeDetectionUtil = $__m.ChangeDetectionUtil; }, function($__m) { - WrappedValue = $__m.WrappedValue; - Pipe = $__m.Pipe; + RECORD_TYPE_SELF = $__m.RECORD_TYPE_SELF; + RECORD_TYPE_PROPERTY = $__m.RECORD_TYPE_PROPERTY; + RECORD_TYPE_LOCAL = $__m.RECORD_TYPE_LOCAL; + RECORD_TYPE_INVOKE_METHOD = $__m.RECORD_TYPE_INVOKE_METHOD; + RECORD_TYPE_CONST = $__m.RECORD_TYPE_CONST; + RECORD_TYPE_INVOKE_CLOSURE = $__m.RECORD_TYPE_INVOKE_CLOSURE; + RECORD_TYPE_PRIMITIVE_OP = $__m.RECORD_TYPE_PRIMITIVE_OP; + RECORD_TYPE_KEYED_ACCESS = $__m.RECORD_TYPE_KEYED_ACCESS; + RECORD_TYPE_PIPE = $__m.RECORD_TYPE_PIPE; + RECORD_TYPE_BINDING_PIPE = $__m.RECORD_TYPE_BINDING_PIPE; + RECORD_TYPE_INTERPOLATE = $__m.RECORD_TYPE_INTERPOLATE; }], execute: function() { - KeyValueChangesFactory = (function() { - function KeyValueChangesFactory() {} - return ($traceurRuntime.createClass)(KeyValueChangesFactory, { - supports: function(obj) { - return assert.returnType((KeyValueChanges.supportsObj(obj)), assert.type.boolean); - }, - create: function(cdRef) { - return assert.returnType((new KeyValueChanges()), Pipe); - } - }, {}); - }()); - $__export("KeyValueChangesFactory", KeyValueChangesFactory); - KeyValueChanges = (function($__super) { - function KeyValueChanges() { - $traceurRuntime.superConstructor(KeyValueChanges).call(this); - this._records = MapWrapper.create(); - this._mapHead = null; - this._previousMapHead = null; - this._changesHead = null; - this._changesTail = null; - this._additionsHead = null; - this._additionsTail = null; - this._removalsHead = null; - this._removalsTail = null; + __esModule = true; + $__export("__esModule", __esModule); + ABSTRACT_CHANGE_DETECTOR = "AbstractChangeDetector"; + UTIL = "ChangeDetectionUtil"; + DISPATCHER_ACCESSOR = "this.dispatcher"; + PIPE_REGISTRY_ACCESSOR = "this.pipeRegistry"; + PROTOS_ACCESSOR = "this.protos"; + DIRECTIVES_ACCESSOR = "this.directiveRecords"; + CONTEXT_ACCESSOR = "this.context"; + IS_CHANGED_LOCAL = "isChanged"; + CHANGES_LOCAL = "changes"; + LOCALS_ACCESSOR = "this.locals"; + MODE_ACCESSOR = "this.mode"; + TEMP_LOCAL = "temp"; + CURRENT_PROTO = "currentProto"; + ChangeDetectorJITGenerator = (function() { + function ChangeDetectorJITGenerator(typeName, changeDetectionStrategy, records, directiveRecords) { + this.typeName = typeName; + this.changeDetectionStrategy = changeDetectionStrategy; + this.records = records; + this.directiveRecords = directiveRecords; + this.localNames = this.getLocalNames(records); + this.changeNames = this.getChangeNames(this.localNames); + this.fieldNames = this.getFieldNames(this.localNames); + this.pipeNames = this.getPipeNames(this.localNames); } - return ($traceurRuntime.createClass)(KeyValueChanges, { - supports: function(obj) { - return assert.returnType((KeyValueChanges.supportsObj(obj)), assert.type.boolean); + return ($traceurRuntime.createClass)(ChangeDetectorJITGenerator, { + getLocalNames: function(records) { + var index = 0; + var names = records.map((function(r) { + var sanitizedName = r.name.replace(new RegExp("\\W", "g"), ''); + return ("" + sanitizedName + index++); + })); + return ["context"].concat(names); }, - transform: function(map) { - if (this.check(map)) { - return WrappedValue.wrap(this); - } else { - return this; - } + getChangeNames: function(localNames) { + return localNames.map((function(n) { + return ("change_" + n); + })); }, - get isDirty() { - return assert.returnType((this._additionsHead !== null || this._changesHead !== null || this._removalsHead !== null), assert.type.boolean); + getFieldNames: function(localNames) { + return localNames.map((function(n) { + return ("this." + n); + })); }, - forEachItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._mapHead; record !== null; record = record._next) { - fn(record); - } + getPipeNames: function(localNames) { + return localNames.map((function(n) { + return ("this." + n + "_pipe"); + })); }, - forEachPreviousItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._previousMapHead; record !== null; record = record._nextPrevious) { - fn(record); - } + generate: function() { + var text = typeTemplate(this.typeName, this.genConstructor(), this.genDetectChanges(), this.genCallOnAllChangesDone(), this.genHydrate()); + return new Function('AbstractChangeDetector', 'ChangeDetectionUtil', 'protos', 'directiveRecords', text)(AbstractChangeDetector, ChangeDetectionUtil, this.records, this.directiveRecords); }, - forEachChangedItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._changesHead; record !== null; record = record._nextChanged) { - fn(record); - } + genConstructor: function() { + return constructorTemplate(this.typeName, this.genFieldDefinitions()); }, - forEachAddedItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._additionsHead; record !== null; record = record._nextAdded) { - fn(record); - } + genHydrate: function() { + var mode = ChangeDetectionUtil.changeDetectionMode(this.changeDetectionStrategy); + return hydrateTemplate(this.typeName, mode, this.genFieldDefinitions(), pipeOnDestroyTemplate(this.getNonNullPipeNames()), this.getDirectiveFieldNames(), this.getDetectorFieldNames()); }, - forEachRemovedItem: function(fn) { - assert.argumentTypes(fn, Function); - var record; - for (record = this._removalsHead; record !== null; record = record._nextRemoved) { - fn(record); - } + getDirectiveFieldNames: function() { + var $__0 = this; + return this.directiveRecords.map((function(d) { + return $__0.getDirective(d.directiveIndex); + })); }, - check: function(map) { + getDetectorFieldNames: function() { var $__0 = this; - this._reset(); - var records = this._records; - var oldSeqRecord = assert.type(this._mapHead, KVChangeRecord); - var lastOldSeqRecord = assert.type(null, KVChangeRecord); - var lastNewSeqRecord = assert.type(null, KVChangeRecord); - var seqChanged = assert.type(false, assert.type.boolean); - this._forEach(map, (function(value, key) { - var newSeqRecord; - if (oldSeqRecord !== null && key === oldSeqRecord.key) { - newSeqRecord = oldSeqRecord; - if (!looseIdentical(value, oldSeqRecord.currentValue)) { - oldSeqRecord.previousValue = oldSeqRecord.currentValue; - oldSeqRecord.currentValue = value; - $__0._addToChanges(oldSeqRecord); - } - } else { - seqChanged = true; - if (oldSeqRecord !== null) { - oldSeqRecord._next = null; - $__0._removeFromSeq(lastOldSeqRecord, oldSeqRecord); - $__0._addToRemovals(oldSeqRecord); - } - if (MapWrapper.contains(records, key)) { - newSeqRecord = MapWrapper.get(records, key); - } else { - newSeqRecord = new KVChangeRecord(key); - MapWrapper.set(records, key, newSeqRecord); - newSeqRecord.currentValue = value; - $__0._addToAdditions(newSeqRecord); - } - } - if (seqChanged) { - if ($__0._isInRemovals(newSeqRecord)) { - $__0._removeFromRemovals(newSeqRecord); - } - if (lastNewSeqRecord == null) { - $__0._mapHead = newSeqRecord; - } else { - lastNewSeqRecord._next = newSeqRecord; - } - } - lastOldSeqRecord = oldSeqRecord; - lastNewSeqRecord = newSeqRecord; - oldSeqRecord = oldSeqRecord === null ? null : oldSeqRecord._next; + return this.directiveRecords.filter((function(r) { + return r.isOnPushChangeDetection(); + })).map((function(d) { + return $__0.getDetector(d.directiveIndex); })); - this._truncate(lastOldSeqRecord, oldSeqRecord); - return assert.returnType((this.isDirty), assert.type.boolean); }, - _reset: function() { - if (this.isDirty) { - var record; - for (record = this._previousMapHead = this._mapHead; record !== null; record = record._next) { - record._nextPrevious = record._next; - } - for (record = this._changesHead; record !== null; record = record._nextChanged) { - record.previousValue = record.currentValue; - } - for (record = this._additionsHead; record != null; record = record._nextAdded) { - record.previousValue = record.currentValue; + getDirective: function(d) { + return ("this.directive_" + d.name); + }, + getDetector: function(d) { + return ("this.detector_" + d.name); + }, + genFieldDefinitions: function() { + var fields = []; + fields = fields.concat(this.fieldNames); + fields = fields.concat(this.getNonNullPipeNames()); + fields = fields.concat(this.getDirectiveFieldNames()); + fields = fields.concat(this.getDetectorFieldNames()); + return fieldDefinitionsTemplate(fields); + }, + getNonNullPipeNames: function() { + var $__0 = this; + var pipes = []; + this.records.forEach((function(r) { + if (r.mode === RECORD_TYPE_PIPE || r.mode === RECORD_TYPE_BINDING_PIPE) { + pipes.push($__0.pipeNames[r.selfIndex]); } - this._changesHead = this._changesTail = null; - this._additionsHead = this._additionsTail = null; - this._removalsHead = this._removalsTail = null; - } + })); + return pipes; }, - _truncate: function(lastRecord, record) { - assert.argumentTypes(lastRecord, KVChangeRecord, record, KVChangeRecord); - while (record !== null) { - if (lastRecord === null) { - this._mapHead = null; - } else { - lastRecord._next = null; + genDetectChanges: function() { + var body = this.genDetectChangesBody(); + return detectChangesTemplate(this.typeName, body); + }, + genCallOnAllChangesDone: function() { + var notifications = []; + var dirs = this.directiveRecords; + for (var i = dirs.length - 1; i >= 0; --i) { + var dir = dirs[i]; + if (dir.callOnAllChangesDone) { + var directive = ("this.directive_" + dir.directiveIndex.name); + notifications.push(onAllChangesDoneTemplate(directive)); } - var nextRecord = record._next; - this._addToRemovals(record); - lastRecord = record; - record = nextRecord; - } - for (var rec = assert.type(this._removalsHead, KVChangeRecord); rec !== null; rec = rec._nextRemoved) { - rec.previousValue = rec.currentValue; - rec.currentValue = null; - MapWrapper.delete(this._records, rec.key); } + return callOnAllChangesDoneTemplate(this.typeName, notifications.join(";\n")); }, - _isInRemovals: function(record) { - assert.argumentTypes(record, KVChangeRecord); - return record === this._removalsHead || record._nextRemoved !== null || record._prevRemoved !== null; + genDetectChangesBody: function() { + var $__0 = this; + var rec = this.records.map((function(r) { + return $__0.genRecord(r); + })).join("\n"); + return detectChangesBodyTemplate(this.genLocalDefinitions(), this.genChangeDefinitions(), rec); }, - _addToRemovals: function(record) { - assert.argumentTypes(record, KVChangeRecord); - if (this._removalsHead === null) { - this._removalsHead = this._removalsTail = record; + genLocalDefinitions: function() { + return localDefinitionsTemplate(this.localNames); + }, + genChangeDefinitions: function() { + return changeDefinitionsTemplate(this.changeNames); + }, + genRecord: function(r) { + if (r.mode === RECORD_TYPE_PIPE || r.mode === RECORD_TYPE_BINDING_PIPE) { + return this.genPipeCheck(r); } else { - this._removalsTail._nextRemoved = record; - record._prevRemoved = this._removalsTail; - this._removalsTail = record; + return this.genReferenceCheck(r); } }, - _removeFromSeq: function(prev, record) { - assert.argumentTypes(prev, KVChangeRecord, record, KVChangeRecord); - var next = record._next; - if (prev === null) { - this._mapHead = next; + genPipeCheck: function(r) { + var context = this.localNames[r.contextIndex]; + var oldValue = this.fieldNames[r.selfIndex]; + var newValue = this.localNames[r.selfIndex]; + var change = this.changeNames[r.selfIndex]; + var pipe = this.pipeNames[r.selfIndex]; + var cdRef = r.mode === RECORD_TYPE_BINDING_PIPE ? "this.ref" : "null"; + var update = this.genUpdateDirectiveOrElement(r); + var addToChanges = this.genAddToChanges(r); + var lastInDirective = this.genLastInDirective(r); + return pipeCheckTemplate(r.selfIndex - 1, context, cdRef, pipe, r.name, oldValue, newValue, change, update, addToChanges, lastInDirective); + }, + genReferenceCheck: function(r) { + var oldValue = this.fieldNames[r.selfIndex]; + var newValue = this.localNames[r.selfIndex]; + var change = this.changeNames[r.selfIndex]; + var assignment = this.genUpdateCurrentValue(r); + var update = this.genUpdateDirectiveOrElement(r); + var addToChanges = this.genAddToChanges(r); + var lastInDirective = this.genLastInDirective(r); + var check = referenceCheckTemplate(r.selfIndex - 1, assignment, oldValue, newValue, change, update, addToChanges, lastInDirective); + if (r.isPureFunction()) { + return this.ifChangedGuard(r, check); } else { - prev._next = next; + return check; } }, - _removeFromRemovals: function(record) { - assert.argumentTypes(record, KVChangeRecord); - var prev = record._prevRemoved; - var next = record._nextRemoved; - if (prev === null) { - this._removalsHead = next; - } else { - prev._nextRemoved = next; + genUpdateCurrentValue: function(r) { + var context = this.getContext(r); + var newValue = this.localNames[r.selfIndex]; + var args = this.genArgs(r); + switch (r.mode) { + case RECORD_TYPE_SELF: + return assignmentTemplate(newValue, context); + case RECORD_TYPE_CONST: + return (newValue + " = " + this.genLiteral(r.funcOrValue)); + case RECORD_TYPE_PROPERTY: + return assignmentTemplate(newValue, (context + "." + r.name)); + case RECORD_TYPE_LOCAL: + return assignmentTemplate(newValue, (LOCALS_ACCESSOR + ".get('" + r.name + "')")); + case RECORD_TYPE_INVOKE_METHOD: + return assignmentTemplate(newValue, (context + "." + r.name + "(" + args + ")")); + case RECORD_TYPE_INVOKE_CLOSURE: + return assignmentTemplate(newValue, (context + "(" + args + ")")); + case RECORD_TYPE_PRIMITIVE_OP: + return assignmentTemplate(newValue, (UTIL + "." + r.name + "(" + args + ")")); + case RECORD_TYPE_INTERPOLATE: + return assignmentTemplate(newValue, this.genInterpolation(r)); + case RECORD_TYPE_KEYED_ACCESS: + var key = this.localNames[r.args[0]]; + return assignmentTemplate(newValue, (context + "[" + key + "]")); + default: + throw new BaseException(("Unknown operation " + r.mode)); } - if (next === null) { - this._removalsTail = prev; + }, + getContext: function(r) { + if (r.contextIndex == -1) { + return this.getDirective(r.directiveIndex); } else { - next._prevRemoved = prev; + return this.localNames[r.contextIndex]; } - record._prevRemoved = record._nextRemoved = null; }, - _addToAdditions: function(record) { - assert.argumentTypes(record, KVChangeRecord); - if (this._additionsHead === null) { - this._additionsHead = this._additionsTail = record; - } else { - this._additionsTail._nextAdded = record; - this._additionsTail = record; + ifChangedGuard: function(r, body) { + var $__0 = this; + return ifChangedGuardTemplate(r.args.map((function(a) { + return $__0.changeNames[a]; + })), body); + }, + genInterpolation: function(r) { + var res = ""; + for (var i = 0; i < r.args.length; ++i) { + res += this.genLiteral(r.fixedArgs[i]); + res += " + "; + res += this.localNames[r.args[i]]; + res += " + "; } + res += this.genLiteral(r.fixedArgs[r.args.length]); + return res; }, - _addToChanges: function(record) { - assert.argumentTypes(record, KVChangeRecord); - if (this._changesHead === null) { - this._changesHead = this._changesTail = record; + genLiteral: function(value) { + return JSON.stringify(value); + }, + genUpdateDirectiveOrElement: function(r) { + if (!r.lastInBinding) + return ""; + var newValue = this.localNames[r.selfIndex]; + var oldValue = this.fieldNames[r.selfIndex]; + var br = r.bindingRecord; + if (br.isDirective()) { + var directiveProperty = (this.getDirective(br.directiveRecord.directiveIndex) + "." + br.propertyName); + return updateDirectiveTemplate(oldValue, newValue, directiveProperty); } else { - this._changesTail._nextChanged = record; - this._changesTail = record; + return updateElementTemplate(oldValue, newValue); } }, - toString: function() { - var items = []; - var previous = []; - var changes = []; - var additions = []; - var removals = []; - var record; - for (record = this._mapHead; record !== null; record = record._next) { - ListWrapper.push(items, stringify(record)); - } - for (record = this._previousMapHead; record !== null; record = record._nextPrevious) { - ListWrapper.push(previous, stringify(record)); - } - for (record = this._changesHead; record !== null; record = record._nextChanged) { - ListWrapper.push(changes, stringify(record)); - } - for (record = this._additionsHead; record !== null; record = record._nextAdded) { - ListWrapper.push(additions, stringify(record)); - } - for (record = this._removalsHead; record !== null; record = record._nextRemoved) { - ListWrapper.push(removals, stringify(record)); + genAddToChanges: function(r) { + var newValue = this.localNames[r.selfIndex]; + var oldValue = this.fieldNames[r.selfIndex]; + return r.bindingRecord.callOnChange() ? addToChangesTemplate(oldValue, newValue) : ""; + }, + genLastInDirective: function(r) { + var onChanges = this.genNotifyOnChanges(r); + var onPush = this.genNotifyOnPushDetectors(r); + return lastInDirectiveTemplate(onChanges, onPush); + }, + genNotifyOnChanges: function(r) { + var br = r.bindingRecord; + if (r.lastInDirective && br.callOnChange()) { + return notifyOnChangesTemplate(this.getDirective(br.directiveRecord.directiveIndex)); + } else { + return ""; } - return assert.returnType(("map: " + items.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" + "additions: " + additions.join(', ') + "\n" + "changes: " + changes.join(', ') + "\n" + "removals: " + removals.join(', ') + "\n"), assert.type.string); }, - _forEach: function(obj, fn) { - assert.argumentTypes(obj, assert.type.any, fn, Function); - if (obj instanceof Map) { - MapWrapper.forEach(obj, fn); + genNotifyOnPushDetectors: function(r) { + var br = r.bindingRecord; + if (r.lastInDirective && br.isOnPushChangeDetection()) { + return notifyOnPushDetectorsTemplate(this.getDetector(br.directiveRecord.directiveIndex)); } else { - StringMapWrapper.forEach(obj, fn); + return ""; } + }, + genArgs: function(r) { + var $__0 = this; + return r.args.map((function(arg) { + return $__0.localNames[arg]; + })).join(", "); } - }, {supportsObj: function(obj) { - return assert.returnType((obj instanceof Map || isJsObject(obj)), assert.type.boolean); - }}, $__super); - }(Pipe)); - $__export("KeyValueChanges", KeyValueChanges); - Object.defineProperty(KeyValueChanges.prototype.forEachItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(KeyValueChanges.prototype.forEachPreviousItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(KeyValueChanges.prototype.forEachChangedItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(KeyValueChanges.prototype.forEachAddedItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(KeyValueChanges.prototype.forEachRemovedItem, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._truncate, "parameters", {get: function() { - return [[KVChangeRecord], [KVChangeRecord]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._isInRemovals, "parameters", {get: function() { - return [[KVChangeRecord]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._addToRemovals, "parameters", {get: function() { - return [[KVChangeRecord]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._removeFromSeq, "parameters", {get: function() { - return [[KVChangeRecord], [KVChangeRecord]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._removeFromRemovals, "parameters", {get: function() { - return [[KVChangeRecord]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._addToAdditions, "parameters", {get: function() { - return [[KVChangeRecord]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._addToChanges, "parameters", {get: function() { - return [[KVChangeRecord]]; - }}); - Object.defineProperty(KeyValueChanges.prototype._forEach, "parameters", {get: function() { - return [[], [Function]]; - }}); - KVChangeRecord = (function() { - function KVChangeRecord(key) { - this.key = key; - this.previousValue = null; - this.currentValue = null; - this._nextPrevious = null; - this._next = null; - this._nextAdded = null; - this._nextRemoved = null; - this._prevRemoved = null; - this._nextChanged = null; + }, {}); + }()); + $__export("ChangeDetectorJITGenerator", ChangeDetectorJITGenerator); + } + }; +}); + +System.register("angular2/src/change_detection/directive_record", ["angular2/src/change_detection/constants", "angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/directive_record"; + var ON_PUSH, + StringWrapper, + __esModule, + DirectiveIndex, + DirectiveRecord; + return { + setters: [function($__m) { + ON_PUSH = $__m.ON_PUSH; + }, function($__m) { + StringWrapper = $__m.StringWrapper; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + DirectiveIndex = (function() { + function DirectiveIndex(elementIndex, directiveIndex) { + this.elementIndex = elementIndex; + this.directiveIndex = directiveIndex; } - return ($traceurRuntime.createClass)(KVChangeRecord, {toString: function() { - return assert.returnType((looseIdentical(this.previousValue, this.currentValue) ? stringify(this.key) : (stringify(this.key) + '[' + stringify(this.previousValue) + '->' + stringify(this.currentValue) + ']')), assert.type.string); + return ($traceurRuntime.createClass)(DirectiveIndex, {get name() { + return (this.elementIndex + "_" + this.directiveIndex); }}, {}); }()); - $__export("KVChangeRecord", KVChangeRecord); + $__export("DirectiveIndex", DirectiveIndex); + DirectiveRecord = (function() { + function DirectiveRecord(directiveIndex, callOnAllChangesDone, callOnChange, changeDetection) { + this.directiveIndex = directiveIndex; + this.callOnAllChangesDone = callOnAllChangesDone; + this.callOnChange = callOnChange; + this.changeDetection = changeDetection; + } + return ($traceurRuntime.createClass)(DirectiveRecord, {isOnPushChangeDetection: function() { + return StringWrapper.equals(this.changeDetection, ON_PUSH); + }}, {}); + }()); + $__export("DirectiveRecord", DirectiveRecord); + } + }; +}); + +System.register("angular2/src/change_detection/coalesce", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/proto_record"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/coalesce"; + var isPresent, + ListWrapper, + MapWrapper, + RECORD_TYPE_SELF, + ProtoRecord, + __esModule; + function coalesce(records) { + var res = ListWrapper.create(); + var indexMap = MapWrapper.create(); + for (var i = 0; i < records.length; ++i) { + var r = records[i]; + var record = _replaceIndices(r, res.length + 1, indexMap); + var matchingRecord = _findMatching(record, res); + if (isPresent(matchingRecord) && record.lastInBinding) { + ListWrapper.push(res, _selfRecord(record, matchingRecord.selfIndex, res.length + 1)); + MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex); + } else if (isPresent(matchingRecord) && !record.lastInBinding) { + MapWrapper.set(indexMap, r.selfIndex, matchingRecord.selfIndex); + } else { + ListWrapper.push(res, record); + MapWrapper.set(indexMap, r.selfIndex, record.selfIndex); + } + } + return res; + } + function _selfRecord(r, contextIndex, selfIndex) { + return new ProtoRecord(RECORD_TYPE_SELF, "self", null, [], r.fixedArgs, contextIndex, r.directiveIndex, selfIndex, r.bindingRecord, r.expressionAsString, r.lastInBinding, r.lastInDirective); + } + function _findMatching(r, rs) { + return ListWrapper.find(rs, (function(rr) { + return rr.mode === r.mode && rr.funcOrValue === r.funcOrValue && rr.contextIndex === r.contextIndex && ListWrapper.equals(rr.args, r.args); + })); + } + function _replaceIndices(r, selfIndex, indexMap) { + var args = ListWrapper.map(r.args, (function(a) { + return _map(indexMap, a); + })); + var contextIndex = _map(indexMap, r.contextIndex); + return new ProtoRecord(r.mode, r.name, r.funcOrValue, args, r.fixedArgs, contextIndex, r.directiveIndex, selfIndex, r.bindingRecord, r.expressionAsString, r.lastInBinding, r.lastInDirective); + } + function _map(indexMap, value) { + var r = MapWrapper.get(indexMap, value); + return isPresent(r) ? r : value; + } + $__export("coalesce", coalesce); + return { + setters: [function($__m) { + isPresent = $__m.isPresent; + }, function($__m) { + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + }, function($__m) { + RECORD_TYPE_SELF = $__m.RECORD_TYPE_SELF; + ProtoRecord = $__m.ProtoRecord; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); } }; }); -System.register("angular2/src/change_detection/pipes/async_pipe", ["rtts_assert/rtts_assert", "angular2/src/facade/async", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe", "angular2/src/change_detection/change_detector_ref"], function($__export) { +System.register("angular2/src/change_detection/binding_record", ["angular2/src/facade/lang"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/pipes/async_pipe"; - var assert, - Observable, - ObservableWrapper, - isBlank, - isPresent, - Pipe, - WrappedValue, - ChangeDetectorRef, - AsyncPipe, - AsyncPipeFactory; + var __moduleName = "angular2/src/change_detection/binding_record"; + var isPresent, + __esModule, + DIRECTIVE, + ELEMENT, + TEXT_NODE, + BindingRecord; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Observable = $__m.Observable; - ObservableWrapper = $__m.ObservableWrapper; - }, function($__m) { - isBlank = $__m.isBlank; isPresent = $__m.isPresent; - }, function($__m) { - Pipe = $__m.Pipe; - WrappedValue = $__m.WrappedValue; - }, function($__m) { - ChangeDetectorRef = $__m.ChangeDetectorRef; }], execute: function() { - AsyncPipe = (function($__super) { - function AsyncPipe(ref) { - assert.argumentTypes(ref, ChangeDetectorRef); - $traceurRuntime.superConstructor(AsyncPipe).call(this); - this._ref = ref; - this._latestValue = null; - this._latestReturnedValue = null; - this._subscription = null; - this._observable = null; + __esModule = true; + $__export("__esModule", __esModule); + DIRECTIVE = "directive"; + ELEMENT = "element"; + TEXT_NODE = "textNode"; + BindingRecord = (function() { + function BindingRecord(mode, implicitReceiver, ast, elementIndex, propertyName, setter, directiveRecord) { + this.mode = mode; + this.implicitReceiver = implicitReceiver; + this.ast = ast; + this.elementIndex = elementIndex; + this.propertyName = propertyName; + this.setter = setter; + this.directiveRecord = directiveRecord; } - return ($traceurRuntime.createClass)(AsyncPipe, { - supports: function(obs) { - return assert.returnType((ObservableWrapper.isObservable(obs)), assert.type.boolean); - }, - onDestroy: function() { - if (isPresent(this._subscription)) { - this._dispose(); - } - ; + return ($traceurRuntime.createClass)(BindingRecord, { + callOnChange: function() { + return isPresent(this.directiveRecord) && this.directiveRecord.callOnChange; }, - transform: function(obs) { - assert.argumentTypes(obs, Observable); - if (isBlank(this._subscription)) { - this._subscribe(obs); - return assert.returnType((null), assert.type.any); - } - if (obs !== this._observable) { - this._dispose(); - return assert.returnType((this.transform(obs)), assert.type.any); - } - if (this._latestValue === this._latestReturnedValue) { - return assert.returnType((this._latestReturnedValue), assert.type.any); - } else { - this._latestReturnedValue = this._latestValue; - return assert.returnType((WrappedValue.wrap(this._latestValue)), assert.type.any); - } + isOnPushChangeDetection: function() { + return isPresent(this.directiveRecord) && this.directiveRecord.isOnPushChangeDetection(); }, - _subscribe: function(obs) { - var $__0 = this; - this._observable = obs; - this._subscription = ObservableWrapper.subscribe(obs, (function(value) { - return $__0._updateLatestValue(value); - }), (function(e) { - throw e; - })); + isDirective: function() { + return this.mode === DIRECTIVE; }, - _dispose: function() { - ObservableWrapper.dispose(this._subscription); - this._latestValue = null; - this._latestReturnedValue = null; - this._subscription = null; - this._observable = null; + isElement: function() { + return this.mode === ELEMENT; }, - _updateLatestValue: function(value) { - assert.argumentTypes(value, Object); - this._latestValue = value; - this._ref.requestCheck(); + isTextNode: function() { + return this.mode === TEXT_NODE; } - }, {}, $__super); - }(Pipe)); - $__export("AsyncPipe", AsyncPipe); - Object.defineProperty(AsyncPipe, "parameters", {get: function() { - return [[ChangeDetectorRef]]; - }}); - Object.defineProperty(AsyncPipe.prototype.transform, "parameters", {get: function() { - return [[Observable]]; - }}); - Object.defineProperty(AsyncPipe.prototype._subscribe, "parameters", {get: function() { - return [[Observable]]; - }}); - Object.defineProperty(AsyncPipe.prototype._updateLatestValue, "parameters", {get: function() { - return [[Object]]; - }}); - AsyncPipeFactory = (function() { - function AsyncPipeFactory() {} - return ($traceurRuntime.createClass)(AsyncPipeFactory, { - supports: function(obs) { - return assert.returnType((ObservableWrapper.isObservable(obs)), assert.type.boolean); + }, { + createForDirective: function(ast, propertyName, setter, directiveRecord) { + return new BindingRecord(DIRECTIVE, 0, ast, 0, propertyName, setter, directiveRecord); }, - create: function(cdRef) { - return assert.returnType((new AsyncPipe(cdRef)), Pipe); + createForElement: function(ast, elementIndex, propertyName) { + return new BindingRecord(ELEMENT, 0, ast, elementIndex, propertyName, null, null); + }, + createForHostProperty: function(directiveIndex, ast, propertyName) { + return new BindingRecord(ELEMENT, directiveIndex, ast, directiveIndex.elementIndex, propertyName, null, null); + }, + createForTextNode: function(ast, elementIndex) { + return new BindingRecord(TEXT_NODE, 0, ast, elementIndex, null, null, null); } - }, {}); + }); }()); - $__export("AsyncPipeFactory", AsyncPipeFactory); + $__export("BindingRecord", BindingRecord); + } + }; +}); + +System.register("angular2/src/change_detection/pipes/pipe_registry", ["angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/di/decorators"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/pipes/pipe_registry"; + var __decorate, + __metadata, + ListWrapper, + isBlank, + BaseException, + Injectable, + __esModule, + PipeRegistry; + return { + setters: [function($__m) { + ListWrapper = $__m.ListWrapper; + }, function($__m) { + isBlank = $__m.isBlank; + BaseException = $__m.BaseException; + }, function($__m) { + Injectable = $__m.Injectable; + }], + execute: function() { + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + PipeRegistry = (($traceurRuntime.createClass)(function(config) { + this.config = config; + }, {get: function(type, obj, cdRef) { + var listOfConfigs = this.config[type]; + if (isBlank(listOfConfigs)) { + throw new BaseException(("Cannot find '" + type + "' pipe supporting object '" + obj + "'")); + } + var matchingConfig = ListWrapper.find(listOfConfigs, (function(pipeConfig) { + return pipeConfig.supports(obj); + })); + if (isBlank(matchingConfig)) { + throw new BaseException(("Cannot find '" + type + "' pipe supporting object '" + obj + "'")); + } + return matchingConfig.create(cdRef); + }}, {})); + $__export("PipeRegistry", PipeRegistry); + $__export("PipeRegistry", PipeRegistry = __decorate([Injectable(), __metadata('design:paramtypes', [Object])], PipeRegistry)); } }; }); -System.register("angular2/src/change_detection/pipes/null_pipe", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe"], function($__export) { +System.register("angular2/src/change_detection/pipes/null_pipe", ["angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe"], function($__export) { "use strict"; var __moduleName = "angular2/src/change_detection/pipes/null_pipe"; - var assert, + var __decorate, + __metadata, isBlank, + CONST, Pipe, WrappedValue, + PipeFactory, + __esModule, NullPipeFactory, NullPipe; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { isBlank = $__m.isBlank; + CONST = $__m.CONST; }, function($__m) { Pipe = $__m.Pipe; WrappedValue = $__m.WrappedValue; + PipeFactory = $__m.PipeFactory; }], execute: function() { - NullPipeFactory = (function() { - function NullPipeFactory() {} - return ($traceurRuntime.createClass)(NullPipeFactory, { + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + NullPipeFactory = (function($__super) { + function $__0() { + $traceurRuntime.superConstructor($__0).call(this); + } + return ($traceurRuntime.createClass)($__0, { supports: function(obj) { - return assert.returnType((NullPipe.supportsObj(obj)), assert.type.boolean); + return NullPipe.supportsObj(obj); }, create: function(cdRef) { - return assert.returnType((new NullPipe()), Pipe); + return new NullPipe(); } - }, {}); - }()); + }, {}, $__super); + }(PipeFactory)); $__export("NullPipeFactory", NullPipeFactory); + $__export("NullPipeFactory", NullPipeFactory = __decorate([CONST(), __metadata('design:paramtypes', [])], NullPipeFactory)); NullPipe = (function($__super) { function NullPipe() { $traceurRuntime.superConstructor(NullPipe).call(this); @@ -13723,7 +9033,7 @@ System.register("angular2/src/change_detection/pipes/null_pipe", ["rtts_assert/r } } }, {supportsObj: function(obj) { - return assert.returnType((isBlank(obj)), assert.type.boolean); + return isBlank(obj); }}, $__super); }(Pipe)); $__export("NullPipe", NullPipe); @@ -13731,3016 +9041,2279 @@ System.register("angular2/src/change_detection/pipes/null_pipe", ["rtts_assert/r }; }); -System.register("angular2/src/core/annotations_impl/visibility", ["angular2/src/facade/lang", "angular2/di"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/annotations_impl/visibility"; - var CONST, - DependencyAnnotation, - Parent, - Ancestor; - return { - setters: [function($__m) { - CONST = $__m.CONST; - }, function($__m) { - DependencyAnnotation = $__m.DependencyAnnotation; - }], - execute: function() { - Parent = (function($__super) { - function Parent() { - $traceurRuntime.superConstructor(Parent).call(this); - } - return ($traceurRuntime.createClass)(Parent, {}, {}, $__super); - }(DependencyAnnotation)); - $__export("Parent", Parent); - Object.defineProperty(Parent, "annotations", {get: function() { - return [new CONST()]; - }}); - Ancestor = (function($__super) { - function Ancestor() { - $traceurRuntime.superConstructor(Ancestor).call(this); - } - return ($traceurRuntime.createClass)(Ancestor, {}, {}, $__super); - }(DependencyAnnotation)); - $__export("Ancestor", Ancestor); - Object.defineProperty(Ancestor, "annotations", {get: function() { - return [new CONST()]; - }}); - } - }; -}); - -System.register("angular2/src/core/compiler/interfaces", [], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/compiler/interfaces"; - var OnChange; - return { - setters: [], - execute: function() { - OnChange = (function() { - function OnChange() {} - return ($traceurRuntime.createClass)(OnChange, {onChange: function(changes) { - throw "OnChange.onChange is not implemented"; - }}, {}); - }()); - $__export("OnChange", OnChange); - } - }; -}); - -System.register("angular2/src/core/annotations_impl/view", ["angular2/src/facade/lang"], function($__export) { +System.register("angular2/src/change_detection/pipes/iterable_changes", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/pipes/pipe"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/annotations_impl/view"; - var ABSTRACT, + var __moduleName = "angular2/src/change_detection/pipes/iterable_changes"; + var __decorate, + __metadata, CONST, - Type, - View; - return { - setters: [function($__m) { - ABSTRACT = $__m.ABSTRACT; - CONST = $__m.CONST; - Type = $__m.Type; - }], - execute: function() { - View = (function() { - function View($__1) { - var $__2 = $__1, - templateUrl = $__2.templateUrl, - template = $__2.template, - directives = $__2.directives, - renderer = $__2.renderer; - this.templateUrl = templateUrl; - this.template = template; - this.directives = directives; - this.renderer = renderer; - } - return ($traceurRuntime.createClass)(View, {}, {}); - }()); - $__export("View", View); - Object.defineProperty(View, "annotations", {get: function() { - return [new CONST()]; - }}); - } - }; -}); - -System.register("angular2/src/dom/dom_adapter", ["rtts_assert/rtts_assert", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/dom/dom_adapter"; - var assert, - ABSTRACT, - BaseException, - DOM, - DomAdapter; - function setRootDomAdapter(adapter) { - assert.argumentTypes(adapter, DomAdapter); - $__export("DOM", DOM = adapter); - } - function _abstract() { - return new BaseException('This method is abstract'); - } - $__export("setRootDomAdapter", setRootDomAdapter); + isListLikeIterable, + iterateListLike, + ListWrapper, + MapWrapper, + isBlank, + isPresent, + stringify, + getMapKey, + looseIdentical, + WrappedValue, + Pipe, + PipeFactory, + __esModule, + IterableChangesFactory, + IterableChanges, + CollectionChangeRecord, + _DuplicateItemRecordList, + _DuplicateMap; return { setters: [function($__m) { - assert = $__m.assert; + CONST = $__m.CONST; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + stringify = $__m.stringify; + getMapKey = $__m.getMapKey; + looseIdentical = $__m.looseIdentical; }, function($__m) { - ABSTRACT = $__m.ABSTRACT; - BaseException = $__m.BaseException; + isListLikeIterable = $__m.isListLikeIterable; + iterateListLike = $__m.iterateListLike; + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + }, function($__m) { + WrappedValue = $__m.WrappedValue; + Pipe = $__m.Pipe; + PipeFactory = $__m.PipeFactory; }], execute: function() { - $__export("DOM", DOM); - Object.defineProperty(setRootDomAdapter, "parameters", {get: function() { - return [[DomAdapter]]; - }}); - DomAdapter = (function() { - function DomAdapter() {} - return ($traceurRuntime.createClass)(DomAdapter, { - get attrToPropMap() { - throw _abstract(); - }, - parse: function(templateHtml) { - assert.argumentTypes(templateHtml, assert.type.string); - throw _abstract(); - }, - query: function(selector) { - assert.argumentTypes(selector, assert.type.string); - throw _abstract(); - }, - querySelector: function(el, selector) { - assert.argumentTypes(el, assert.type.any, selector, assert.type.string); - throw _abstract(); - }, - querySelectorAll: function(el, selector) { - assert.argumentTypes(el, assert.type.any, selector, assert.type.string); - throw _abstract(); - }, - on: function(el, evt, listener) { - throw _abstract(); - }, - onAndCancel: function(el, evt, listener) { - throw _abstract(); - }, - dispatchEvent: function(el, evt) { - throw _abstract(); - }, - createMouseEvent: function(eventType) { - throw _abstract(); - }, - createEvent: function(eventType) { - throw _abstract(); - }, - getInnerHTML: function(el) { - throw _abstract(); - }, - getOuterHTML: function(el) { - throw _abstract(); - }, - nodeName: function(node) { - throw _abstract(); - }, - nodeValue: function(node) { - throw _abstract(); - }, - type: function(node) { - throw _abstract(); - }, - content: function(node) { - throw _abstract(); - }, - firstChild: function(el) { - throw _abstract(); - }, - nextSibling: function(el) { - throw _abstract(); - }, - parentElement: function(el) { - throw _abstract(); - }, - childNodes: function(el) { - throw _abstract(); - }, - childNodesAsList: function(el) { - throw _abstract(); - }, - clearNodes: function(el) { - throw _abstract(); - }, - appendChild: function(el, node) { - throw _abstract(); - }, - removeChild: function(el, node) { - throw _abstract(); - }, - replaceChild: function(el, newNode, oldNode) { - throw _abstract(); - }, - remove: function(el) { - throw _abstract(); - }, - insertBefore: function(el, node) { - throw _abstract(); - }, - insertAllBefore: function(el, nodes) { - throw _abstract(); - }, - insertAfter: function(el, node) { - throw _abstract(); - }, - setInnerHTML: function(el, value) { - throw _abstract(); - }, - getText: function(el) { - throw _abstract(); - }, - setText: function(el, value) { - assert.argumentTypes(el, assert.type.any, value, assert.type.string); - throw _abstract(); - }, - getValue: function(el) { - throw _abstract(); - }, - setValue: function(el, value) { - assert.argumentTypes(el, assert.type.any, value, assert.type.string); - throw _abstract(); + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + IterableChangesFactory = (function($__super) { + function $__1() { + $traceurRuntime.superConstructor($__1).call(this); + } + return ($traceurRuntime.createClass)($__1, { + supports: function(obj) { + return IterableChanges.supportsObj(obj); }, - getChecked: function(el) { - throw _abstract(); + create: function(cdRef) { + return new IterableChanges(); + } + }, {}, $__super); + }(PipeFactory)); + $__export("IterableChangesFactory", IterableChangesFactory); + $__export("IterableChangesFactory", IterableChangesFactory = __decorate([CONST(), __metadata('design:paramtypes', [])], IterableChangesFactory)); + IterableChanges = (function($__super) { + function IterableChanges() { + $traceurRuntime.superConstructor(IterableChanges).call(this); + this._collection = null; + this._length = null; + this._linkedRecords = null; + this._unlinkedRecords = null; + this._previousItHead = null; + this._itHead = null; + this._itTail = null; + this._additionsHead = null; + this._additionsTail = null; + this._movesHead = null; + this._movesTail = null; + this._removalsHead = null; + this._removalsTail = null; + } + return ($traceurRuntime.createClass)(IterableChanges, { + supports: function(obj) { + return IterableChanges.supportsObj(obj); }, - setChecked: function(el, value) { - assert.argumentTypes(el, assert.type.any, value, assert.type.boolean); - throw _abstract(); + get collection() { + return this._collection; }, - createTemplate: function(html) { - throw _abstract(); + get length() { + return this._length; }, - createElement: function(tagName) { - var doc = arguments[1] !== (void 0) ? arguments[1] : null; - throw _abstract(); + forEachItem: function(fn) { + var record; + for (record = this._itHead; record !== null; record = record._next) { + fn(record); + } }, - createTextNode: function(text) { - var doc = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(text, assert.type.string, doc, assert.type.any); - throw _abstract(); + forEachPreviousItem: function(fn) { + var record; + for (record = this._previousItHead; record !== null; record = record._nextPrevious) { + fn(record); + } }, - createScriptTag: function(attrName, attrValue) { - var doc = arguments[2] !== (void 0) ? arguments[2] : null; - assert.argumentTypes(attrName, assert.type.string, attrValue, assert.type.string, doc, assert.type.any); - throw _abstract(); + forEachAddedItem: function(fn) { + var record; + for (record = this._additionsHead; record !== null; record = record._nextAdded) { + fn(record); + } }, - createStyleElement: function(css) { - var doc = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(css, assert.type.string, doc, assert.type.any); - throw _abstract(); + forEachMovedItem: function(fn) { + var record; + for (record = this._movesHead; record !== null; record = record._nextMoved) { + fn(record); + } }, - createShadowRoot: function(el) { - throw _abstract(); + forEachRemovedItem: function(fn) { + var record; + for (record = this._removalsHead; record !== null; record = record._nextRemoved) { + fn(record); + } }, - getShadowRoot: function(el) { - throw _abstract(); + transform: function(collection) { + if (this.check(collection)) { + return WrappedValue.wrap(this); + } else { + return this; + } }, - getHost: function(el) { - throw _abstract(); + check: function(collection) { + var $__0 = this; + this._reset(); + var record = this._itHead; + var mayBeDirty = false; + var index; + var item; + if (ListWrapper.isList(collection)) { + var list = collection; + this._length = collection.length; + for (index = 0; index < this._length; index++) { + item = list[index]; + if (record === null || !looseIdentical(record.item, item)) { + record = this._mismatch(record, item, index); + mayBeDirty = true; + } else if (mayBeDirty) { + record = this._verifyReinsertion(record, item, index); + } + record = record._next; + } + } else { + index = 0; + iterateListLike(collection, (function(item) { + if (record === null || !looseIdentical(record.item, item)) { + record = $__0._mismatch(record, item, index); + mayBeDirty = true; + } else if (mayBeDirty) { + record = $__0._verifyReinsertion(record, item, index); + } + record = record._next; + index++; + })); + this._length = index; + } + this._truncate(record); + this._collection = collection; + return this.isDirty; }, - getDistributedNodes: function(el) { - throw _abstract(); + get isDirty() { + return this._additionsHead !== null || this._movesHead !== null || this._removalsHead !== null; }, - clone: function(node) { - throw _abstract(); + _reset: function() { + if (this.isDirty) { + var record; + var nextRecord; + for (record = this._previousItHead = this._itHead; record !== null; record = record._next) { + record._nextPrevious = record._next; + } + for (record = this._additionsHead; record !== null; record = record._nextAdded) { + record.previousIndex = record.currentIndex; + } + this._additionsHead = this._additionsTail = null; + for (record = this._movesHead; record !== null; record = nextRecord) { + record.previousIndex = record.currentIndex; + nextRecord = record._nextMoved; + } + this._movesHead = this._movesTail = null; + this._removalsHead = this._removalsTail = null; + } }, - hasProperty: function(element, name) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string); - throw _abstract(); + _mismatch: function(record, item, index) { + var previousRecord; + if (record === null) { + previousRecord = this._itTail; + } else { + previousRecord = record._prev; + this._remove(record); + } + record = this._linkedRecords === null ? null : this._linkedRecords.get(item, index); + if (record !== null) { + this._moveAfter(record, previousRecord, index); + } else { + record = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(item); + if (record !== null) { + this._reinsertAfter(record, previousRecord, index); + } else { + record = this._addAfter(new CollectionChangeRecord(item), previousRecord, index); + } + } + return record; }, - getElementsByClassName: function(element, name) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string); - throw _abstract(); + _verifyReinsertion: function(record, item, index) { + var reinsertRecord = this._unlinkedRecords === null ? null : this._unlinkedRecords.get(item); + if (reinsertRecord !== null) { + record = this._reinsertAfter(reinsertRecord, record._prev, index); + } else if (record.currentIndex != index) { + record.currentIndex = index; + this._addToMoves(record, index); + } + return record; }, - getElementsByTagName: function(element, name) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string); - throw _abstract(); + _truncate: function(record) { + while (record !== null) { + var nextRecord = record._next; + this._addToRemovals(this._unlink(record)); + record = nextRecord; + } + if (this._unlinkedRecords !== null) { + this._unlinkedRecords.clear(); + } + if (this._additionsTail !== null) { + this._additionsTail._nextAdded = null; + } + if (this._movesTail !== null) { + this._movesTail._nextMoved = null; + } + if (this._itTail !== null) { + this._itTail._next = null; + } + if (this._removalsTail !== null) { + this._removalsTail._nextRemoved = null; + } }, - classList: function(element) { - throw _abstract(); + _reinsertAfter: function(record, prevRecord, index) { + if (this._unlinkedRecords !== null) { + this._unlinkedRecords.remove(record); + } + var prev = record._prevRemoved; + var next = record._nextRemoved; + if (prev === null) { + this._removalsHead = next; + } else { + prev._nextRemoved = next; + } + if (next === null) { + this._removalsTail = prev; + } else { + next._prevRemoved = prev; + } + this._insertAfter(record, prevRecord, index); + this._addToMoves(record, index); + return record; }, - addClass: function(element, classname) { - assert.argumentTypes(element, assert.type.any, classname, assert.type.string); - throw _abstract(); + _moveAfter: function(record, prevRecord, index) { + this._unlink(record); + this._insertAfter(record, prevRecord, index); + this._addToMoves(record, index); + return record; }, - removeClass: function(element, classname) { - assert.argumentTypes(element, assert.type.any, classname, assert.type.string); - throw _abstract(); + _addAfter: function(record, prevRecord, index) { + this._insertAfter(record, prevRecord, index); + if (this._additionsTail === null) { + this._additionsTail = this._additionsHead = record; + } else { + this._additionsTail = this._additionsTail._nextAdded = record; + } + return record; }, - hasClass: function(element, classname) { - assert.argumentTypes(element, assert.type.any, classname, assert.type.string); - throw _abstract(); + _insertAfter: function(record, prevRecord, index) { + var next = prevRecord === null ? this._itHead : prevRecord._next; + record._next = next; + record._prev = prevRecord; + if (next === null) { + this._itTail = record; + } else { + next._prev = record; + } + if (prevRecord === null) { + this._itHead = record; + } else { + prevRecord._next = record; + } + if (this._linkedRecords === null) { + this._linkedRecords = new _DuplicateMap(); + } + this._linkedRecords.put(record); + record.currentIndex = index; + return record; }, - setStyle: function(element, stylename, stylevalue) { - assert.argumentTypes(element, assert.type.any, stylename, assert.type.string, stylevalue, assert.type.string); - throw _abstract(); + _remove: function(record) { + return this._addToRemovals(this._unlink(record)); }, - removeStyle: function(element, stylename) { - assert.argumentTypes(element, assert.type.any, stylename, assert.type.string); - throw _abstract(); + _unlink: function(record) { + if (this._linkedRecords !== null) { + this._linkedRecords.remove(record); + } + var prev = record._prev; + var next = record._next; + if (prev === null) { + this._itHead = next; + } else { + prev._next = next; + } + if (next === null) { + this._itTail = prev; + } else { + next._prev = prev; + } + return record; }, - getStyle: function(element, stylename) { - assert.argumentTypes(element, assert.type.any, stylename, assert.type.string); - throw _abstract(); + _addToMoves: function(record, toIndex) { + if (record.previousIndex === toIndex) { + return record; + } + if (this._movesTail === null) { + this._movesTail = this._movesHead = record; + } else { + this._movesTail = this._movesTail._nextMoved = record; + } + return record; }, - tagName: function(element) { - throw _abstract(); + _addToRemovals: function(record) { + if (this._unlinkedRecords === null) { + this._unlinkedRecords = new _DuplicateMap(); + } + this._unlinkedRecords.put(record); + record.currentIndex = null; + record._nextRemoved = null; + if (this._removalsTail === null) { + this._removalsTail = this._removalsHead = record; + record._prevRemoved = null; + } else { + record._prevRemoved = this._removalsTail; + this._removalsTail = this._removalsTail._nextRemoved = record; + } + return record; }, - attributeMap: function(element) { - throw _abstract(); + toString: function() { + var record; + var list = []; + for (record = this._itHead; record !== null; record = record._next) { + ListWrapper.push(list, record); + } + var previous = []; + for (record = this._previousItHead; record !== null; record = record._nextPrevious) { + ListWrapper.push(previous, record); + } + var additions = []; + for (record = this._additionsHead; record !== null; record = record._nextAdded) { + ListWrapper.push(additions, record); + } + var moves = []; + for (record = this._movesHead; record !== null; record = record._nextMoved) { + ListWrapper.push(moves, record); + } + var removals = []; + for (record = this._removalsHead; record !== null; record = record._nextRemoved) { + ListWrapper.push(removals, record); + } + return "collection: " + list.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" + "additions: " + additions.join(', ') + "\n" + "moves: " + moves.join(', ') + "\n" + "removals: " + removals.join(', ') + "\n"; + } + }, {supportsObj: function(obj) { + return isListLikeIterable(obj); + }}, $__super); + }(Pipe)); + $__export("IterableChanges", IterableChanges); + CollectionChangeRecord = (function() { + function CollectionChangeRecord(item) { + this.currentIndex = null; + this.previousIndex = null; + this.item = item; + this._nextPrevious = null; + this._prev = null; + this._next = null; + this._prevDup = null; + this._nextDup = null; + this._prevRemoved = null; + this._nextRemoved = null; + this._nextAdded = null; + this._nextMoved = null; + } + return ($traceurRuntime.createClass)(CollectionChangeRecord, {toString: function() { + return this.previousIndex === this.currentIndex ? stringify(this.item) : stringify(this.item) + '[' + stringify(this.previousIndex) + '->' + stringify(this.currentIndex) + ']'; + }}, {}); + }()); + $__export("CollectionChangeRecord", CollectionChangeRecord); + _DuplicateItemRecordList = (function() { + function _DuplicateItemRecordList() { + this._head = null; + this._tail = null; + } + return ($traceurRuntime.createClass)(_DuplicateItemRecordList, { + add: function(record) { + if (this._head === null) { + this._head = this._tail = record; + record._nextDup = null; + record._prevDup = null; + } else { + this._tail._nextDup = record; + record._prevDup = this._tail; + record._nextDup = null; + this._tail = record; + } }, - getAttribute: function(element, attribute) { - assert.argumentTypes(element, assert.type.any, attribute, assert.type.string); - throw _abstract(); + get: function(item, afterIndex) { + var record; + for (record = this._head; record !== null; record = record._nextDup) { + if ((afterIndex === null || afterIndex < record.currentIndex) && looseIdentical(record.item, item)) { + return record; + } + } + return null; }, - setAttribute: function(element, name, value) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string, value, assert.type.string); - throw _abstract(); + remove: function(record) { + var prev = record._prevDup; + var next = record._nextDup; + if (prev === null) { + this._head = next; + } else { + prev._nextDup = next; + } + if (next === null) { + this._tail = prev; + } else { + next._prevDup = prev; + } + return this._head === null; + } + }, {}); + }()); + _DuplicateMap = (function() { + function _DuplicateMap() { + this.map = MapWrapper.create(); + } + return ($traceurRuntime.createClass)(_DuplicateMap, { + put: function(record) { + var key = getMapKey(record.item); + var duplicates = MapWrapper.get(this.map, key); + if (!isPresent(duplicates)) { + duplicates = new _DuplicateItemRecordList(); + MapWrapper.set(this.map, key, duplicates); + } + duplicates.add(record); }, - removeAttribute: function(element, attribute) { - assert.argumentTypes(element, assert.type.any, attribute, assert.type.string); - throw _abstract(); + get: function(value) { + var afterIndex = arguments[1] !== (void 0) ? arguments[1] : null; + var key = getMapKey(value); + var recordList = MapWrapper.get(this.map, key); + return isBlank(recordList) ? null : recordList.get(value, afterIndex); }, - templateAwareRoot: function(el) { - throw _abstract(); + remove: function(record) { + var key = getMapKey(record.item); + var recordList = MapWrapper.get(this.map, key); + if (recordList.remove(record)) { + MapWrapper.delete(this.map, key); + } + return record; }, - createHtmlDocument: function() { - throw _abstract(); + get isEmpty() { + return MapWrapper.size(this.map) === 0; }, - defaultDoc: function() { - throw _abstract(); + clear: function() { + MapWrapper.clear(this.map); }, - getBoundingClientRect: function(el) { - throw _abstract(); + toString: function() { + return '_DuplicateMap(' + stringify(this.map) + ')'; + } + }, {}); + }()); + } + }; +}); + +System.register("angular2/src/change_detection/pipes/keyvalue_changes", ["angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/pipes/keyvalue_changes"; + var __decorate, + __metadata, + ListWrapper, + MapWrapper, + StringMapWrapper, + stringify, + looseIdentical, + isJsObject, + CONST, + WrappedValue, + Pipe, + PipeFactory, + __esModule, + KeyValueChangesFactory, + KeyValueChanges, + KVChangeRecord; + return { + setters: [function($__m) { + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + StringMapWrapper = $__m.StringMapWrapper; + }, function($__m) { + stringify = $__m.stringify; + looseIdentical = $__m.looseIdentical; + isJsObject = $__m.isJsObject; + CONST = $__m.CONST; + }, function($__m) { + WrappedValue = $__m.WrappedValue; + Pipe = $__m.Pipe; + PipeFactory = $__m.PipeFactory; + }], + execute: function() { + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + KeyValueChangesFactory = (function($__super) { + function $__1() { + $traceurRuntime.superConstructor($__1).call(this); + } + return ($traceurRuntime.createClass)($__1, { + supports: function(obj) { + return KeyValueChanges.supportsObj(obj); }, - getTitle: function() { - throw _abstract(); + create: function(cdRef) { + return new KeyValueChanges(); + } + }, {}, $__super); + }(PipeFactory)); + $__export("KeyValueChangesFactory", KeyValueChangesFactory); + $__export("KeyValueChangesFactory", KeyValueChangesFactory = __decorate([CONST(), __metadata('design:paramtypes', [])], KeyValueChangesFactory)); + KeyValueChanges = (function($__super) { + function KeyValueChanges() { + $traceurRuntime.superConstructor(KeyValueChanges).call(this); + this._records = MapWrapper.create(); + this._mapHead = null; + this._previousMapHead = null; + this._changesHead = null; + this._changesTail = null; + this._additionsHead = null; + this._additionsTail = null; + this._removalsHead = null; + this._removalsTail = null; + } + return ($traceurRuntime.createClass)(KeyValueChanges, { + supports: function(obj) { + return KeyValueChanges.supportsObj(obj); }, - setTitle: function(newTitle) { - assert.argumentTypes(newTitle, assert.type.string); - throw _abstract(); + transform: function(map) { + if (this.check(map)) { + return WrappedValue.wrap(this); + } else { + return this; + } }, - elementMatches: function(n, selector) { - assert.argumentTypes(n, assert.type.any, selector, assert.type.string); - throw _abstract(); + get isDirty() { + return this._additionsHead !== null || this._changesHead !== null || this._removalsHead !== null; }, - isTemplateElement: function(el) { - assert.argumentTypes(el, assert.type.any); - throw _abstract(); + forEachItem: function(fn) { + var record; + for (record = this._mapHead; record !== null; record = record._next) { + fn(record); + } }, - isTextNode: function(node) { - throw _abstract(); + forEachPreviousItem: function(fn) { + var record; + for (record = this._previousMapHead; record !== null; record = record._nextPrevious) { + fn(record); + } }, - isCommentNode: function(node) { - throw _abstract(); + forEachChangedItem: function(fn) { + var record; + for (record = this._changesHead; record !== null; record = record._nextChanged) { + fn(record); + } }, - isElementNode: function(node) { - throw _abstract(); + forEachAddedItem: function(fn) { + var record; + for (record = this._additionsHead; record !== null; record = record._nextAdded) { + fn(record); + } }, - hasShadowRoot: function(node) { - throw _abstract(); + forEachRemovedItem: function(fn) { + var record; + for (record = this._removalsHead; record !== null; record = record._nextRemoved) { + fn(record); + } }, - isShadowRoot: function(node) { - throw _abstract(); + check: function(map) { + var $__0 = this; + this._reset(); + var records = this._records; + var oldSeqRecord = this._mapHead; + var lastOldSeqRecord = null; + var lastNewSeqRecord = null; + var seqChanged = false; + this._forEach(map, (function(value, key) { + var newSeqRecord; + if (oldSeqRecord !== null && key === oldSeqRecord.key) { + newSeqRecord = oldSeqRecord; + if (!looseIdentical(value, oldSeqRecord.currentValue)) { + oldSeqRecord.previousValue = oldSeqRecord.currentValue; + oldSeqRecord.currentValue = value; + $__0._addToChanges(oldSeqRecord); + } + } else { + seqChanged = true; + if (oldSeqRecord !== null) { + oldSeqRecord._next = null; + $__0._removeFromSeq(lastOldSeqRecord, oldSeqRecord); + $__0._addToRemovals(oldSeqRecord); + } + if (MapWrapper.contains(records, key)) { + newSeqRecord = MapWrapper.get(records, key); + } else { + newSeqRecord = new KVChangeRecord(key); + MapWrapper.set(records, key, newSeqRecord); + newSeqRecord.currentValue = value; + $__0._addToAdditions(newSeqRecord); + } + } + if (seqChanged) { + if ($__0._isInRemovals(newSeqRecord)) { + $__0._removeFromRemovals(newSeqRecord); + } + if (lastNewSeqRecord == null) { + $__0._mapHead = newSeqRecord; + } else { + lastNewSeqRecord._next = newSeqRecord; + } + } + lastOldSeqRecord = oldSeqRecord; + lastNewSeqRecord = newSeqRecord; + oldSeqRecord = oldSeqRecord === null ? null : oldSeqRecord._next; + })); + this._truncate(lastOldSeqRecord, oldSeqRecord); + return this.isDirty; }, - importIntoDoc: function(node) { - throw _abstract(); + _reset: function() { + if (this.isDirty) { + var record; + for (record = this._previousMapHead = this._mapHead; record !== null; record = record._next) { + record._nextPrevious = record._next; + } + for (record = this._changesHead; record !== null; record = record._nextChanged) { + record.previousValue = record.currentValue; + } + for (record = this._additionsHead; record != null; record = record._nextAdded) { + record.previousValue = record.currentValue; + } + this._changesHead = this._changesTail = null; + this._additionsHead = this._additionsTail = null; + this._removalsHead = this._removalsTail = null; + } }, - isPageRule: function(rule) { - throw _abstract(); + _truncate: function(lastRecord, record) { + while (record !== null) { + if (lastRecord === null) { + this._mapHead = null; + } else { + lastRecord._next = null; + } + var nextRecord = record._next; + this._addToRemovals(record); + lastRecord = record; + record = nextRecord; + } + for (var rec = this._removalsHead; rec !== null; rec = rec._nextRemoved) { + rec.previousValue = rec.currentValue; + rec.currentValue = null; + MapWrapper.delete(this._records, rec.key); + } }, - isStyleRule: function(rule) { - throw _abstract(); + _isInRemovals: function(record) { + return record === this._removalsHead || record._nextRemoved !== null || record._prevRemoved !== null; }, - isMediaRule: function(rule) { - throw _abstract(); + _addToRemovals: function(record) { + if (this._removalsHead === null) { + this._removalsHead = this._removalsTail = record; + } else { + this._removalsTail._nextRemoved = record; + record._prevRemoved = this._removalsTail; + this._removalsTail = record; + } }, - isKeyframesRule: function(rule) { - throw _abstract(); + _removeFromSeq: function(prev, record) { + var next = record._next; + if (prev === null) { + this._mapHead = next; + } else { + prev._next = next; + } }, - getHref: function(element) { - throw _abstract(); + _removeFromRemovals: function(record) { + var prev = record._prevRemoved; + var next = record._nextRemoved; + if (prev === null) { + this._removalsHead = next; + } else { + prev._nextRemoved = next; + } + if (next === null) { + this._removalsTail = prev; + } else { + next._prevRemoved = prev; + } + record._prevRemoved = record._nextRemoved = null; }, - getEventKey: function(event) { - throw _abstract(); + _addToAdditions: function(record) { + if (this._additionsHead === null) { + this._additionsHead = this._additionsTail = record; + } else { + this._additionsTail._nextAdded = record; + this._additionsTail = record; + } }, - resolveAndSetHref: function(element, baseUrl, href) { - assert.argumentTypes(element, assert.type.any, baseUrl, assert.type.string, href, assert.type.string); - throw _abstract(); + _addToChanges: function(record) { + if (this._changesHead === null) { + this._changesHead = this._changesTail = record; + } else { + this._changesTail._nextChanged = record; + this._changesTail = record; + } }, - cssToRules: function(css) { - assert.argumentTypes(css, assert.type.string); - throw _abstract(); + toString: function() { + var items = []; + var previous = []; + var changes = []; + var additions = []; + var removals = []; + var record; + for (record = this._mapHead; record !== null; record = record._next) { + ListWrapper.push(items, stringify(record)); + } + for (record = this._previousMapHead; record !== null; record = record._nextPrevious) { + ListWrapper.push(previous, stringify(record)); + } + for (record = this._changesHead; record !== null; record = record._nextChanged) { + ListWrapper.push(changes, stringify(record)); + } + for (record = this._additionsHead; record !== null; record = record._nextAdded) { + ListWrapper.push(additions, stringify(record)); + } + for (record = this._removalsHead; record !== null; record = record._nextRemoved) { + ListWrapper.push(removals, stringify(record)); + } + return "map: " + items.join(', ') + "\n" + "previous: " + previous.join(', ') + "\n" + "additions: " + additions.join(', ') + "\n" + "changes: " + changes.join(', ') + "\n" + "removals: " + removals.join(', ') + "\n"; }, - supportsDOMEvents: function() { - throw _abstract(); + _forEach: function(obj, fn) { + if (obj instanceof Map) { + MapWrapper.forEach(obj, fn); + } else { + StringMapWrapper.forEach(obj, fn); + } + } + }, {supportsObj: function(obj) { + return obj instanceof Map || isJsObject(obj); + }}, $__super); + }(Pipe)); + $__export("KeyValueChanges", KeyValueChanges); + KVChangeRecord = (function() { + function KVChangeRecord(key) { + this.key = key; + this.previousValue = null; + this.currentValue = null; + this._nextPrevious = null; + this._next = null; + this._nextAdded = null; + this._nextRemoved = null; + this._prevRemoved = null; + this._nextChanged = null; + } + return ($traceurRuntime.createClass)(KVChangeRecord, {toString: function() { + return looseIdentical(this.previousValue, this.currentValue) ? stringify(this.key) : (stringify(this.key) + '[' + stringify(this.previousValue) + '->' + stringify(this.currentValue) + ']'); + }}, {}); + }()); + $__export("KVChangeRecord", KVChangeRecord); + } + }; +}); + +System.register("angular2/src/change_detection/pipes/promise_pipe", ["angular2/src/facade/async", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/pipes/promise_pipe"; + var PromiseWrapper, + isBlank, + Pipe, + WrappedValue, + __esModule, + PromisePipe, + PromisePipeFactory; + return { + setters: [function($__m) { + PromiseWrapper = $__m.PromiseWrapper; + }, function($__m) { + isBlank = $__m.isBlank; + }, function($__m) { + Pipe = $__m.Pipe; + WrappedValue = $__m.WrappedValue; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + PromisePipe = (function($__super) { + function PromisePipe(ref) { + $traceurRuntime.superConstructor(PromisePipe).call(this); + this._ref = ref; + this._latestValue = null; + this._latestReturnedValue = null; + } + return ($traceurRuntime.createClass)(PromisePipe, { + supports: function(promise) { + return PromiseWrapper.isPromise(promise); }, - supportsNativeShadowDOM: function() { - throw _abstract(); + onDestroy: function() {}, + transform: function(promise) { + var $__0 = this; + if (isBlank(this._sourcePromise)) { + this._sourcePromise = promise; + promise.then((function(val) { + if ($__0._sourcePromise === promise) { + $__0._updateLatestValue(val); + } + })); + return null; + } + if (promise !== this._sourcePromise) { + this._sourcePromise = null; + return this.transform(promise); + } + if (this._latestValue === this._latestReturnedValue) { + return this._latestReturnedValue; + } else { + this._latestReturnedValue = this._latestValue; + return WrappedValue.wrap(this._latestValue); + } }, - getGlobalEventTarget: function(target) { - assert.argumentTypes(target, assert.type.string); - throw _abstract(); + _updateLatestValue: function(value) { + this._latestValue = value; + this._ref.requestCheck(); + } + }, {}, $__super); + }(Pipe)); + $__export("PromisePipe", PromisePipe); + PromisePipeFactory = (function() { + function PromisePipeFactory() {} + return ($traceurRuntime.createClass)(PromisePipeFactory, { + supports: function(promise) { + return PromiseWrapper.isPromise(promise); + }, + create: function(cdRef) { + return new PromisePipe(cdRef); } }, {}); }()); - $__export("DomAdapter", DomAdapter); - Object.defineProperty(DomAdapter, "annotations", {get: function() { - return [new ABSTRACT()]; - }}); - Object.defineProperty(DomAdapter.prototype.parse, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.query, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.querySelector, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.querySelectorAll, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.setText, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.setValue, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.setChecked, "parameters", {get: function() { - return [[], [assert.type.boolean]]; - }}); - Object.defineProperty(DomAdapter.prototype.createTextNode, "parameters", {get: function() { - return [[assert.type.string], []]; - }}); - Object.defineProperty(DomAdapter.prototype.createScriptTag, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; - }}); - Object.defineProperty(DomAdapter.prototype.createStyleElement, "parameters", {get: function() { - return [[assert.type.string], []]; - }}); - Object.defineProperty(DomAdapter.prototype.hasProperty, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.getElementsByClassName, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.getElementsByTagName, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.addClass, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.removeClass, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.hasClass, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.setStyle, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.removeStyle, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.getStyle, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.getAttribute, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.setAttribute, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.removeAttribute, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.setTitle, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.elementMatches, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(DomAdapter.prototype.isTemplateElement, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - Object.defineProperty(DomAdapter.prototype.resolveAndSetHref, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.string]]; + $__export("PromisePipeFactory", PromisePipeFactory); + } + }; +}); + +System.register("angular2/src/core/annotations_impl/visibility", ["angular2/src/facade/lang", "angular2/src/di/annotations_impl"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/annotations_impl/visibility"; + var CONST, + DependencyAnnotation, + Parent, + Ancestor; + return { + setters: [function($__m) { + CONST = $__m.CONST; + }, function($__m) { + DependencyAnnotation = $__m.DependencyAnnotation; + }], + execute: function() { + Parent = (function($__super) { + function Parent() { + $traceurRuntime.superConstructor(Parent).call(this); + } + return ($traceurRuntime.createClass)(Parent, {}, {}, $__super); + }(DependencyAnnotation)); + $__export("Parent", Parent); + Object.defineProperty(Parent, "annotations", {get: function() { + return [new CONST()]; }}); - Object.defineProperty(DomAdapter.prototype.cssToRules, "parameters", {get: function() { - return [[assert.type.string]]; + Ancestor = (function($__super) { + function Ancestor() { + $traceurRuntime.superConstructor(Ancestor).call(this); + } + return ($traceurRuntime.createClass)(Ancestor, {}, {}, $__super); + }(DependencyAnnotation)); + $__export("Ancestor", Ancestor); + Object.defineProperty(Ancestor, "annotations", {get: function() { + return [new CONST()]; }}); - Object.defineProperty(DomAdapter.prototype.getGlobalEventTarget, "parameters", {get: function() { - return [[assert.type.string]]; + } + }; +}); + +System.register("angular2/src/core/compiler/interfaces", [], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/compiler/interfaces"; + var OnChange; + return { + setters: [], + execute: function() { + OnChange = (function() { + function OnChange() {} + return ($traceurRuntime.createClass)(OnChange, {onChange: function(changes) { + throw "OnChange.onChange is not implemented"; + }}, {}); + }()); + $__export("OnChange", OnChange); + } + }; +}); + +System.register("angular2/src/core/annotations_impl/view", ["angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/annotations_impl/view"; + var ABSTRACT, + CONST, + Type, + View; + return { + setters: [function($__m) { + ABSTRACT = $__m.ABSTRACT; + CONST = $__m.CONST; + Type = $__m.Type; + }], + execute: function() { + View = (function() { + function View($__1) { + var $__2 = $__1, + templateUrl = $__2.templateUrl, + template = $__2.template, + directives = $__2.directives, + renderer = $__2.renderer; + this.templateUrl = templateUrl; + this.template = template; + this.directives = directives; + this.renderer = renderer; + } + return ($traceurRuntime.createClass)(View, {}, {}); + }()); + $__export("View", View); + Object.defineProperty(View, "annotations", {get: function() { + return [new CONST()]; }}); } }; }); -System.register("angular2/src/dom/generic_browser_adapter", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter"], function($__export) { +System.register("angular2/src/di/type_literal", [], function($__export) { "use strict"; - var __moduleName = "angular2/src/dom/generic_browser_adapter"; - var assert, - ABSTRACT, - List, - ListWrapper, - isPresent, - isFunction, - DomAdapter, - GenericBrowserDomAdapter; + var __moduleName = "angular2/src/di/type_literal"; + var TypeLiteral; return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - ABSTRACT = $__m.ABSTRACT; - isPresent = $__m.isPresent; - isFunction = $__m.isFunction; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - DomAdapter = $__m.DomAdapter; - }], + setters: [], execute: function() { - GenericBrowserDomAdapter = (function($__super) { - function GenericBrowserDomAdapter() { - $traceurRuntime.superConstructor(GenericBrowserDomAdapter).apply(this, arguments); - } - return ($traceurRuntime.createClass)(GenericBrowserDomAdapter, { - getDistributedNodes: function(el) { - return el.getDistributedNodes(); - }, - resolveAndSetHref: function(el, baseUrl, href) { - assert.argumentTypes(el, assert.type.any, baseUrl, assert.type.string, href, assert.type.string); - el.href = href == null ? baseUrl : baseUrl + '/../' + href; - }, - cssToRules: function(css) { - assert.argumentTypes(css, assert.type.string); - var style = this.createStyleElement(css); - this.appendChild(this.defaultDoc().head, style); - var rules = ListWrapper.create(); - if (isPresent(style.sheet)) { - try { - var rawRules = style.sheet.cssRules; - rules = ListWrapper.createFixedSize(rawRules.length); - for (var i = 0; i < rawRules.length; i++) { - rules[i] = rawRules[i]; - } - } catch (e) {} - } else {} - this.remove(style); - return assert.returnType((rules), List); - }, - supportsDOMEvents: function() { - return assert.returnType((true), assert.type.boolean); - }, - supportsNativeShadowDOM: function() { - return assert.returnType((isFunction(this.defaultDoc().body.createShadowRoot)), assert.type.boolean); - } - }, {}, $__super); - }(DomAdapter)); - $__export("GenericBrowserDomAdapter", GenericBrowserDomAdapter); - Object.defineProperty(GenericBrowserDomAdapter, "annotations", {get: function() { - return [new ABSTRACT()]; - }}); - Object.defineProperty(GenericBrowserDomAdapter.prototype.resolveAndSetHref, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(GenericBrowserDomAdapter.prototype.cssToRules, "parameters", {get: function() { - return [[assert.type.string]]; - }}); + TypeLiteral = (function() { + function TypeLiteral() {} + return ($traceurRuntime.createClass)(TypeLiteral, {get type() { + throw new Error("Type literals are only supported in Dart"); + }}, {}); + }()); + $__export("TypeLiteral", TypeLiteral); } }; }); -System.register("angular2/src/core/annotations_impl/annotations", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/di", "angular2/change_detection"], function($__export) { +System.register("angular2/src/di/exceptions", ["angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/annotations_impl/annotations"; - var assert, - ABSTRACT, - CONST, - normalizeBlank, - isPresent, - ListWrapper, - List, - Injectable, - DEFAULT, - Directive, - Component, - Decorator, - onDestroy, - onChange, - onAllChangesDone; + var __moduleName = "angular2/src/di/exceptions"; + var ListWrapper, + stringify, + BaseException, + AbstractBindingError, + NoBindingError, + AsyncBindingError, + CyclicDependencyError, + InstantiationError, + InvalidBindingError, + NoAnnotationError; + function findFirstClosedCycle(keys) { + var res = []; + for (var i = 0; i < keys.length; ++i) { + if (ListWrapper.contains(res, keys[i])) { + ListWrapper.push(res, keys[i]); + return res; + } else { + ListWrapper.push(res, keys[i]); + } + } + return res; + } + function constructResolvingPath(keys) { + if (keys.length > 1) { + var reversed = findFirstClosedCycle(ListWrapper.reversed(keys)); + var tokenStrs = ListWrapper.map(reversed, (function(k) { + return stringify(k.token); + })); + return " (" + tokenStrs.join(' -> ') + ")"; + } else { + return ""; + } + } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - ABSTRACT = $__m.ABSTRACT; - CONST = $__m.CONST; - normalizeBlank = $__m.normalizeBlank; - isPresent = $__m.isPresent; - }, function($__m) { ListWrapper = $__m.ListWrapper; - List = $__m.List; }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { - DEFAULT = $__m.DEFAULT; + stringify = $__m.stringify; + BaseException = $__m.BaseException; }], execute: function() { - Directive = (function($__super) { - function Directive() { - var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, - selector = $__1.selector, - properties = $__1.properties, - events = $__1.events, - hostListeners = $__1.hostListeners, - hostProperties = $__1.hostProperties, - lifecycle = $__1.lifecycle; - $traceurRuntime.superConstructor(Directive).call(this); - this.selector = selector; - this.properties = properties; - this.events = events; - this.hostListeners = hostListeners; - this.hostProperties = hostProperties; - this.lifecycle = lifecycle; + AbstractBindingError = (function($__super) { + function AbstractBindingError(key, constructResolvingMessage) { + $traceurRuntime.superConstructor(AbstractBindingError).call(this); + this.keys = [key]; + this.constructResolvingMessage = constructResolvingMessage; + this.message = this.constructResolvingMessage(this.keys); } - return ($traceurRuntime.createClass)(Directive, {hasLifecycleHook: function(hook) { - assert.argumentTypes(hook, assert.type.string); - return assert.returnType((isPresent(this.lifecycle) ? ListWrapper.contains(this.lifecycle, hook) : false), assert.type.boolean); - }}, {}, $__super); - }(Injectable)); - $__export("Directive", Directive); - Object.defineProperty(Directive, "annotations", {get: function() { - return [new ABSTRACT(), new CONST()]; - }}); - Object.defineProperty(Directive.prototype.hasLifecycleHook, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Component = (function($__super) { - function Component() { - var $__2; - var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, - selector = $__1.selector, - properties = $__1.properties, - events = $__1.events, - hostListeners = $__1.hostListeners, - hostProperties = $__1.hostProperties, - injectables = $__1.injectables, - lifecycle = $__1.lifecycle, - changeDetection = ($__2 = $__1.changeDetection) === void 0 ? DEFAULT : $__2; - $traceurRuntime.superConstructor(Component).call(this, { - selector: selector, - properties: properties, - events: events, - hostListeners: hostListeners, - hostProperties: hostProperties, - lifecycle: lifecycle + return ($traceurRuntime.createClass)(AbstractBindingError, { + addKey: function(key) { + ListWrapper.push(this.keys, key); + this.message = this.constructResolvingMessage(this.keys); + }, + toString: function() { + return this.message; + } + }, {}, $__super); + }(BaseException)); + $__export("AbstractBindingError", AbstractBindingError); + NoBindingError = (function($__super) { + function NoBindingError(key) { + $traceurRuntime.superConstructor(NoBindingError).call(this, key, function(keys) { + var first = stringify(ListWrapper.first(keys).token); + return ("No provider for " + first + "!" + constructResolvingPath(keys)); }); - this.changeDetection = changeDetection; - this.injectables = injectables; } - return ($traceurRuntime.createClass)(Component, {}, {}, $__super); - }(Directive)); - $__export("Component", Component); - Object.defineProperty(Component, "annotations", {get: function() { - return [new CONST()]; - }}); - Decorator = (function($__super) { - function Decorator() { - var $__2; - var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, - selector = $__1.selector, - properties = $__1.properties, - events = $__1.events, - hostListeners = $__1.hostListeners, - hostProperties = $__1.hostProperties, - lifecycle = $__1.lifecycle, - compileChildren = ($__2 = $__1.compileChildren) === void 0 ? true : $__2; - $traceurRuntime.superConstructor(Decorator).call(this, { - selector: selector, - properties: properties, - events: events, - hostListeners: hostListeners, - hostProperties: hostProperties, - lifecycle: lifecycle + return ($traceurRuntime.createClass)(NoBindingError, {}, {}, $__super); + }(AbstractBindingError)); + $__export("NoBindingError", NoBindingError); + AsyncBindingError = (function($__super) { + function AsyncBindingError(key) { + $traceurRuntime.superConstructor(AsyncBindingError).call(this, key, function(keys) { + var first = stringify(ListWrapper.first(keys).token); + return ("Cannot instantiate " + first + " synchronously. It is provided as a promise!" + constructResolvingPath(keys)); }); - this.compileChildren = compileChildren; } - return ($traceurRuntime.createClass)(Decorator, {}, {}, $__super); - }(Directive)); - $__export("Decorator", Decorator); - Object.defineProperty(Decorator, "annotations", {get: function() { - return [new CONST()]; - }}); - onDestroy = "onDestroy"; - $__export("onDestroy", onDestroy); - onChange = "onChange"; - $__export("onChange", onChange); - onAllChangesDone = "onAllChangesDone"; - $__export("onAllChangesDone", onAllChangesDone); + return ($traceurRuntime.createClass)(AsyncBindingError, {}, {}, $__super); + }(AbstractBindingError)); + $__export("AsyncBindingError", AsyncBindingError); + CyclicDependencyError = (function($__super) { + function CyclicDependencyError(key) { + $traceurRuntime.superConstructor(CyclicDependencyError).call(this, key, function(keys) { + return ("Cannot instantiate cyclic dependency!" + constructResolvingPath(keys)); + }); + } + return ($traceurRuntime.createClass)(CyclicDependencyError, {}, {}, $__super); + }(AbstractBindingError)); + $__export("CyclicDependencyError", CyclicDependencyError); + InstantiationError = (function($__super) { + function InstantiationError(cause, key) { + $traceurRuntime.superConstructor(InstantiationError).call(this, key, function(keys) { + var first = stringify(ListWrapper.first(keys).token); + return ("Error during instantiation of " + first + "!" + constructResolvingPath(keys) + ". ORIGINAL ERROR: " + cause); + }); + this.cause = cause; + this.causeKey = key; + } + return ($traceurRuntime.createClass)(InstantiationError, {}, {}, $__super); + }(AbstractBindingError)); + $__export("InstantiationError", InstantiationError); + InvalidBindingError = (function($__super) { + function InvalidBindingError(binding) { + $traceurRuntime.superConstructor(InvalidBindingError).call(this); + this.message = "Invalid binding - only instances of Binding and Type are allowed, got: " + binding.toString(); + } + return ($traceurRuntime.createClass)(InvalidBindingError, {toString: function() { + return this.message; + }}, {}, $__super); + }(BaseException)); + $__export("InvalidBindingError", InvalidBindingError); + NoAnnotationError = (function($__super) { + function NoAnnotationError(typeOrFunc) { + $traceurRuntime.superConstructor(NoAnnotationError).call(this); + this.message = "Cannot resolve all parameters for " + stringify(typeOrFunc) + ". " + 'Make sure they all have valid type or annotations.'; + } + return ($traceurRuntime.createClass)(NoAnnotationError, {toString: function() { + return this.message; + }}, {}, $__super); + }(BaseException)); + $__export("NoAnnotationError", NoAnnotationError); } }; }); -System.register("angular2/src/core/compiler/directive_metadata", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/core/annotations_impl/annotations", "angular2/di"], function($__export) { +System.register("angular2/src/di/opaque_token", [], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/compiler/directive_metadata"; - var assert, - Type, - List, - Directive, - ResolvedBinding, - DirectiveMetadata; + var __moduleName = "angular2/src/di/opaque_token"; + var OpaqueToken; return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Type = $__m.Type; - }, function($__m) { - List = $__m.List; - }, function($__m) { - Directive = $__m.Directive; - }, function($__m) { - ResolvedBinding = $__m.ResolvedBinding; - }], + setters: [], execute: function() { - DirectiveMetadata = (function() { - function DirectiveMetadata(type, annotation, resolvedInjectables) { - assert.argumentTypes(type, Type, annotation, Directive, resolvedInjectables, assert.genericType(List, ResolvedBinding)); - this.annotation = annotation; - this.type = type; - this.resolvedInjectables = resolvedInjectables; + OpaqueToken = (function() { + function OpaqueToken(desc) { + this._desc = ("Token(" + desc + ")"); } - return ($traceurRuntime.createClass)(DirectiveMetadata, {}, {}); + return ($traceurRuntime.createClass)(OpaqueToken, {toString: function() { + return this._desc; + }}, {}); }()); - $__export("DirectiveMetadata", DirectiveMetadata); - Object.defineProperty(DirectiveMetadata, "parameters", {get: function() { - return [[Type], [Directive], [assert.genericType(List, ResolvedBinding)]]; - }}); - } - }; -}); - -System.register("angular2/src/facade/math", ["angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/facade/math"; - var global, - Math, - NaN; - return { - setters: [function($__m) { - global = $__m.global; - }], - execute: function() { - Math = global.Math; - $__export("Math", Math); - NaN = global.NaN; - $__export("NaN", NaN); - } - }; -}); - -System.register("angular2/src/core/annotations_impl/di", ["angular2/src/facade/lang", "angular2/di"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/annotations_impl/di"; - var CONST, - DependencyAnnotation, - Attribute, - Query; - return { - setters: [function($__m) { - CONST = $__m.CONST; - }, function($__m) { - DependencyAnnotation = $__m.DependencyAnnotation; - }], - execute: function() { - Attribute = (function($__super) { - function Attribute(attributeName) { - $traceurRuntime.superConstructor(Attribute).call(this); - this.attributeName = attributeName; - } - return ($traceurRuntime.createClass)(Attribute, {get token() { - return this; - }}, {}, $__super); - }(DependencyAnnotation)); - $__export("Attribute", Attribute); - Object.defineProperty(Attribute, "annotations", {get: function() { - return [new CONST()]; - }}); - Query = (function($__super) { - function Query(directive) { - $traceurRuntime.superConstructor(Query).call(this); - this.directive = directive; - } - return ($traceurRuntime.createClass)(Query, {}, {}, $__super); - }(DependencyAnnotation)); - $__export("Query", Query); - Object.defineProperty(Query, "annotations", {get: function() { - return [new CONST()]; - }}); + $__export("OpaqueToken", OpaqueToken); } }; }); -System.register("angular2/src/render/api", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/collection", "angular2/change_detection"], function($__export) { +System.register("angular2/src/dom/dom_adapter", ["angular2/src/facade/lang"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/api"; - var assert, - isPresent, - Promise, - List, - Map, - ASTWithSource, - EventBinding, - ElementBinder, - DirectiveBinder, - ProtoViewDto, - DirectiveMetadata, - RenderProtoViewRef, - RenderViewRef, - RenderViewContainerRef, - ViewDefinition, - Renderer, - EventDispatcher; + var __moduleName = "angular2/src/dom/dom_adapter"; + var BaseException, + __esModule, + DOM, + DomAdapter; + function setRootDomAdapter(adapter) { + $__export("DOM", DOM = adapter); + } + function _abstract() { + return new BaseException('This method is abstract'); + } + $__export("setRootDomAdapter", setRootDomAdapter); return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - Promise = $__m.Promise; - }, function($__m) { - List = $__m.List; - Map = $__m.Map; - }, function($__m) { - ASTWithSource = $__m.ASTWithSource; + BaseException = $__m.BaseException; }], execute: function() { - EventBinding = (function() { - function EventBinding(fullName, source) { - assert.argumentTypes(fullName, assert.type.string, source, ASTWithSource); - this.fullName = fullName; - this.source = source; - } - return ($traceurRuntime.createClass)(EventBinding, {}, {}); - }()); - $__export("EventBinding", EventBinding); - Object.defineProperty(EventBinding, "parameters", {get: function() { - return [[assert.type.string], [ASTWithSource]]; - }}); - ElementBinder = (function() { - function ElementBinder($__1) { - var $__2 = $__1, - index = $__2.index, - parentIndex = $__2.parentIndex, - distanceToParent = $__2.distanceToParent, - directives = $__2.directives, - nestedProtoView = $__2.nestedProtoView, - propertyBindings = $__2.propertyBindings, - variableBindings = $__2.variableBindings, - eventBindings = $__2.eventBindings, - textBindings = $__2.textBindings, - readAttributes = $__2.readAttributes; - this.index = index; - this.parentIndex = parentIndex; - this.distanceToParent = distanceToParent; - this.directives = directives; - this.nestedProtoView = nestedProtoView; - this.propertyBindings = propertyBindings; - this.variableBindings = variableBindings; - this.eventBindings = eventBindings; - this.textBindings = textBindings; - this.readAttributes = readAttributes; - } - return ($traceurRuntime.createClass)(ElementBinder, {}, {}); - }()); - $__export("ElementBinder", ElementBinder); - DirectiveBinder = (function() { - function DirectiveBinder($__1) { - var $__2 = $__1, - directiveIndex = $__2.directiveIndex, - propertyBindings = $__2.propertyBindings, - eventBindings = $__2.eventBindings, - hostPropertyBindings = $__2.hostPropertyBindings; - this.directiveIndex = directiveIndex; - this.propertyBindings = propertyBindings; - this.eventBindings = eventBindings; - this.hostPropertyBindings = hostPropertyBindings; - } - return ($traceurRuntime.createClass)(DirectiveBinder, {}, {}); - }()); - $__export("DirectiveBinder", DirectiveBinder); - ProtoViewDto = (function() { - function ProtoViewDto() { - var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, - render = $__1.render, - elementBinders = $__1.elementBinders, - variableBindings = $__1.variableBindings, - type = $__1.type; - this.render = render; - this.elementBinders = elementBinders; - this.variableBindings = variableBindings; - this.type = type; - } - return ($traceurRuntime.createClass)(ProtoViewDto, {}, { - get HOST_VIEW_TYPE() { - return 0; + __esModule = true; + $__export("__esModule", __esModule); + $__export("DOM", DOM); + DomAdapter = (function() { + function DomAdapter() {} + return ($traceurRuntime.createClass)(DomAdapter, { + logError: function(error) { + throw _abstract(); + }, + get attrToPropMap() { + throw _abstract(); + }, + parse: function(templateHtml) { + throw _abstract(); + }, + query: function(selector) { + throw _abstract(); + }, + querySelector: function(el, selector) { + throw _abstract(); + }, + querySelectorAll: function(el, selector) { + throw _abstract(); + }, + on: function(el, evt, listener) { + throw _abstract(); + }, + onAndCancel: function(el, evt, listener) { + throw _abstract(); + }, + dispatchEvent: function(el, evt) { + throw _abstract(); + }, + createMouseEvent: function(eventType) { + throw _abstract(); + }, + createEvent: function(eventType) { + throw _abstract(); + }, + getInnerHTML: function(el) { + throw _abstract(); + }, + getOuterHTML: function(el) { + throw _abstract(); + }, + nodeName: function(node) { + throw _abstract(); }, - get COMPONENT_VIEW_TYPE() { - return 1; + nodeValue: function(node) { + throw _abstract(); }, - get EMBEDDED_VIEW_TYPE() { - return 1; - } - }); - }()); - $__export("ProtoViewDto", ProtoViewDto); - DirectiveMetadata = (function() { - function DirectiveMetadata($__1) { - var $__2 = $__1, - id = $__2.id, - selector = $__2.selector, - compileChildren = $__2.compileChildren, - hostListeners = $__2.hostListeners, - hostProperties = $__2.hostProperties, - properties = $__2.properties, - readAttributes = $__2.readAttributes, - type = $__2.type; - this.id = id; - this.selector = selector; - this.compileChildren = isPresent(compileChildren) ? compileChildren : true; - this.hostListeners = hostListeners; - this.hostProperties = hostProperties; - this.properties = properties; - this.readAttributes = readAttributes; - this.type = type; - } - return ($traceurRuntime.createClass)(DirectiveMetadata, {}, { - get DECORATOR_TYPE() { - return 0; + type: function(node) { + throw _abstract(); }, - get COMPONENT_TYPE() { - return 1; - } - }); - }()); - $__export("DirectiveMetadata", DirectiveMetadata); - RenderProtoViewRef = (function() { - function RenderProtoViewRef() {} - return ($traceurRuntime.createClass)(RenderProtoViewRef, {}, {}); - }()); - $__export("RenderProtoViewRef", RenderProtoViewRef); - RenderViewRef = (function() { - function RenderViewRef() {} - return ($traceurRuntime.createClass)(RenderViewRef, {}, {}); - }()); - $__export("RenderViewRef", RenderViewRef); - RenderViewContainerRef = (function() { - function RenderViewContainerRef(view, elementIndex) { - assert.argumentTypes(view, RenderViewRef, elementIndex, assert.type.number); - this.view = view; - this.elementIndex = elementIndex; - } - return ($traceurRuntime.createClass)(RenderViewContainerRef, {}, {}); - }()); - $__export("RenderViewContainerRef", RenderViewContainerRef); - Object.defineProperty(RenderViewContainerRef, "parameters", {get: function() { - return [[RenderViewRef], [assert.type.number]]; - }}); - ViewDefinition = (function() { - function ViewDefinition($__1) { - var $__2 = $__1, - componentId = $__2.componentId, - absUrl = $__2.absUrl, - template = $__2.template, - directives = $__2.directives; - this.componentId = componentId; - this.absUrl = absUrl; - this.template = template; - this.directives = directives; - } - return ($traceurRuntime.createClass)(ViewDefinition, {}, {}); - }()); - $__export("ViewDefinition", ViewDefinition); - Renderer = (function() { - function Renderer() {} - return ($traceurRuntime.createClass)(Renderer, { - createHostProtoView: function(componentId) { - return assert.returnType((null), assert.genericType(Promise, ProtoViewDto)); + content: function(node) { + throw _abstract(); }, - createImperativeComponentProtoView: function(rendererId) { - return assert.returnType((null), assert.genericType(Promise, ProtoViewDto)); + firstChild: function(el) { + throw _abstract(); }, - compile: function(template) { - assert.argumentTypes(template, ViewDefinition); - return assert.returnType((null), assert.genericType(Promise, ProtoViewDto)); + nextSibling: function(el) { + throw _abstract(); }, - mergeChildComponentProtoViews: function(protoViewRef, componentProtoViewRefs) { - assert.argumentTypes(protoViewRef, RenderProtoViewRef, componentProtoViewRefs, assert.genericType(List, RenderProtoViewRef)); - return null; + parentElement: function(el) { + throw _abstract(); }, - createViewInContainer: function(vcRef, atIndex, protoViewRef) { - assert.argumentTypes(vcRef, RenderViewContainerRef, atIndex, assert.type.number, protoViewRef, RenderProtoViewRef); - return assert.returnType((null), assert.genericType(List, RenderViewRef)); + childNodes: function(el) { + throw _abstract(); }, - destroyViewInContainer: function(vcRef, atIndex) { - assert.argumentTypes(vcRef, RenderViewContainerRef, atIndex, assert.type.number); + childNodesAsList: function(el) { + throw _abstract(); }, - insertViewIntoContainer: function(vcRef, atIndex, view) { - assert.argumentTypes(vcRef, RenderViewContainerRef, atIndex, assert.type.number, view, RenderViewRef); + clearNodes: function(el) { + throw _abstract(); }, - detachViewFromContainer: function(vcRef, atIndex) { - assert.argumentTypes(vcRef, RenderViewContainerRef, atIndex, assert.type.number); + appendChild: function(el, node) { + throw _abstract(); }, - createDynamicComponentView: function(hostViewRef, elementIndex, componentProtoViewRef) { - assert.argumentTypes(hostViewRef, RenderViewRef, elementIndex, assert.type.number, componentProtoViewRef, RenderProtoViewRef); - return assert.returnType((null), assert.genericType(List, RenderViewRef)); + removeChild: function(el, node) { + throw _abstract(); }, - destroyDynamicComponentView: function(hostViewRef, elementIndex) { - assert.argumentTypes(hostViewRef, RenderViewRef, elementIndex, assert.type.number); + replaceChild: function(el, newNode, oldNode) { + throw _abstract(); }, - createInPlaceHostView: function(parentViewRef, hostElementSelector, hostProtoViewRef) { - assert.argumentTypes(parentViewRef, RenderViewRef, hostElementSelector, assert.type.any, hostProtoViewRef, RenderProtoViewRef); - return assert.returnType((null), assert.genericType(List, RenderViewRef)); + remove: function(el) { + throw _abstract(); }, - destroyInPlaceHostView: function(parentViewRef, hostViewRef) { - assert.argumentTypes(parentViewRef, RenderViewRef, hostViewRef, RenderViewRef); + insertBefore: function(el, node) { + throw _abstract(); }, - setElementProperty: function(view, elementIndex, propertyName, propertyValue) { - assert.argumentTypes(view, RenderViewRef, elementIndex, assert.type.number, propertyName, assert.type.string, propertyValue, assert.type.any); + insertAllBefore: function(el, nodes) { + throw _abstract(); }, - setText: function(view, textNodeIndex, text) { - assert.argumentTypes(view, RenderViewRef, textNodeIndex, assert.type.number, text, assert.type.string); + insertAfter: function(el, node) { + throw _abstract(); }, - setEventDispatcher: function(viewRef, dispatcher) { - assert.argumentTypes(viewRef, RenderViewRef, dispatcher, assert.type.any); + setInnerHTML: function(el, value) { + throw _abstract(); }, - flush: function() {} - }, {}); - }()); - $__export("Renderer", Renderer); - Object.defineProperty(Renderer.prototype.compile, "parameters", {get: function() { - return [[ViewDefinition]]; - }}); - Object.defineProperty(Renderer.prototype.mergeChildComponentProtoViews, "parameters", {get: function() { - return [[RenderProtoViewRef], [assert.genericType(List, RenderProtoViewRef)]]; - }}); - Object.defineProperty(Renderer.prototype.createViewInContainer, "parameters", {get: function() { - return [[RenderViewContainerRef], [assert.type.number], [RenderProtoViewRef]]; - }}); - Object.defineProperty(Renderer.prototype.destroyViewInContainer, "parameters", {get: function() { - return [[RenderViewContainerRef], [assert.type.number]]; - }}); - Object.defineProperty(Renderer.prototype.insertViewIntoContainer, "parameters", {get: function() { - return [[RenderViewContainerRef], [assert.type.number], [RenderViewRef]]; - }}); - Object.defineProperty(Renderer.prototype.detachViewFromContainer, "parameters", {get: function() { - return [[RenderViewContainerRef], [assert.type.number]]; - }}); - Object.defineProperty(Renderer.prototype.createDynamicComponentView, "parameters", {get: function() { - return [[RenderViewRef], [assert.type.number], [RenderProtoViewRef]]; - }}); - Object.defineProperty(Renderer.prototype.destroyDynamicComponentView, "parameters", {get: function() { - return [[RenderViewRef], [assert.type.number]]; - }}); - Object.defineProperty(Renderer.prototype.createInPlaceHostView, "parameters", {get: function() { - return [[RenderViewRef], [], [RenderProtoViewRef]]; - }}); - Object.defineProperty(Renderer.prototype.destroyInPlaceHostView, "parameters", {get: function() { - return [[RenderViewRef], [RenderViewRef]]; - }}); - Object.defineProperty(Renderer.prototype.setElementProperty, "parameters", {get: function() { - return [[RenderViewRef], [assert.type.number], [assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(Renderer.prototype.setText, "parameters", {get: function() { - return [[RenderViewRef], [assert.type.number], [assert.type.string]]; - }}); - Object.defineProperty(Renderer.prototype.setEventDispatcher, "parameters", {get: function() { - return [[RenderViewRef], [assert.type.any]]; - }}); - EventDispatcher = (function() { - function EventDispatcher() {} - return ($traceurRuntime.createClass)(EventDispatcher, {dispatchEvent: function(elementIndex, eventName, locals) { - assert.argumentTypes(elementIndex, assert.type.number, eventName, assert.type.string, locals, assert.genericType(Map, assert.type.string, assert.type.any)); - }}, {}); - }()); - $__export("EventDispatcher", EventDispatcher); - Object.defineProperty(EventDispatcher.prototype.dispatchEvent, "parameters", {get: function() { - return [[assert.type.number], [assert.type.string], [assert.genericType(Map, assert.type.string, assert.type.any)]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/view/view_container", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/view/view"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/view/view_container"; - var assert, - isPresent, - isBlank, - BaseException, - ListWrapper, - MapWrapper, - List, - DOM, - viewModule, - ViewContainer; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - List = $__m.List; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - viewModule = $__m; - }], - execute: function() { - ViewContainer = (function() { - function ViewContainer(parentView, boundElementIndex) { - assert.argumentTypes(parentView, viewModule.RenderView, boundElementIndex, assert.type.number); - this.parentView = parentView; - this.boundElementIndex = boundElementIndex; - this.views = []; - } - return ($traceurRuntime.createClass)(ViewContainer, { - get: function(index) { - assert.argumentTypes(index, assert.type.number); - return assert.returnType((this.views[index]), viewModule.RenderView); + getText: function(el) { + throw _abstract(); }, - size: function() { - return this.views.length; + setText: function(el, value) { + throw _abstract(); }, - _siblingToInsertAfter: function(index) { - assert.argumentTypes(index, assert.type.number); - if (index == 0) - return this.parentView.boundElements[this.boundElementIndex]; - return ListWrapper.last(this.views[index - 1].rootNodes); + getValue: function(el) { + throw _abstract(); }, - _checkHydrated: function() { - if (!this.parentView.hydrated) - throw new BaseException('Cannot change dehydrated ViewContainer'); + setValue: function(el, value) { + throw _abstract(); }, - _getDirectParentLightDom: function() { - return this.parentView.getDirectParentLightDom(this.boundElementIndex); + getChecked: function(el) { + throw _abstract(); }, - clear: function() { - this._checkHydrated(); - for (var i = this.views.length - 1; i >= 0; i--) { - this.detach(i); - } - if (isPresent(this._getDirectParentLightDom())) { - this._getDirectParentLightDom().redistribute(); - } + setChecked: function(el, value) { + throw _abstract(); + }, + createTemplate: function(html) { + throw _abstract(); + }, + createElement: function(tagName) { + var doc = arguments[1] !== (void 0) ? arguments[1] : null; + throw _abstract(); + }, + createTextNode: function(text) { + var doc = arguments[1] !== (void 0) ? arguments[1] : null; + throw _abstract(); + }, + createScriptTag: function(attrName, attrValue) { + var doc = arguments[2] !== (void 0) ? arguments[2] : null; + throw _abstract(); + }, + createStyleElement: function(css) { + var doc = arguments[1] !== (void 0) ? arguments[1] : null; + throw _abstract(); + }, + createShadowRoot: function(el) { + throw _abstract(); + }, + getShadowRoot: function(el) { + throw _abstract(); + }, + getHost: function(el) { + throw _abstract(); + }, + getDistributedNodes: function(el) { + throw _abstract(); + }, + clone: function(node) { + throw _abstract(); + }, + hasProperty: function(element, name) { + throw _abstract(); + }, + getElementsByClassName: function(element, name) { + throw _abstract(); + }, + getElementsByTagName: function(element, name) { + throw _abstract(); + }, + classList: function(element) { + throw _abstract(); + }, + addClass: function(element, classname) { + throw _abstract(); + }, + removeClass: function(element, classname) { + throw _abstract(); + }, + hasClass: function(element, classname) { + throw _abstract(); + }, + setStyle: function(element, stylename, stylevalue) { + throw _abstract(); + }, + removeStyle: function(element, stylename) { + throw _abstract(); + }, + getStyle: function(element, stylename) { + throw _abstract(); }, - insert: function(view) { - var atIndex = arguments[1] !== (void 0) ? arguments[1] : -1; - this._checkHydrated(); - if (atIndex == -1) - atIndex = this.views.length; - ListWrapper.insert(this.views, atIndex, view); - if (isBlank(this._getDirectParentLightDom())) { - ViewContainer.moveViewNodesAfterSibling(this._siblingToInsertAfter(atIndex), view); - } else { - this._getDirectParentLightDom().redistribute(); - } - if (isPresent(this.parentView.hostLightDom)) { - this.parentView.hostLightDom.redistribute(); - } - return assert.returnType((view), viewModule.RenderView); + tagName: function(element) { + throw _abstract(); }, - detach: function(atIndex) { - assert.argumentTypes(atIndex, assert.type.number); - this._checkHydrated(); - var detachedView = this.get(atIndex); - ListWrapper.removeAt(this.views, atIndex); - if (isBlank(this._getDirectParentLightDom())) { - ViewContainer.removeViewNodes(detachedView); - } else { - this._getDirectParentLightDom().redistribute(); - } - if (isPresent(this.parentView.hostLightDom)) { - this.parentView.hostLightDom.redistribute(); - } - return detachedView; + attributeMap: function(element) { + throw _abstract(); }, - contentTagContainers: function() { - return this.views; + hasAttribute: function(element, attribute) { + throw _abstract(); }, - nodes: function() { - var r = []; - for (var i = 0; i < this.views.length; ++i) { - r = ListWrapper.concat(r, this.views[i].rootNodes); - } - return assert.returnType((r), List); - } - }, { - moveViewNodesAfterSibling: function(sibling, view) { - for (var i = view.rootNodes.length - 1; i >= 0; --i) { - DOM.insertAfter(sibling, view.rootNodes[i]); - } + getAttribute: function(element, attribute) { + throw _abstract(); }, - removeViewNodes: function(view) { - var len = view.rootNodes.length; - if (len == 0) - return ; - var parent = view.rootNodes[0].parentNode; - for (var i = len - 1; i >= 0; --i) { - DOM.removeChild(parent, view.rootNodes[i]); - } - } - }); - }()); - $__export("ViewContainer", ViewContainer); - Object.defineProperty(ViewContainer, "parameters", {get: function() { - return [[viewModule.RenderView], [assert.type.number]]; - }}); - Object.defineProperty(ViewContainer.prototype.get, "parameters", {get: function() { - return [[assert.type.number]]; - }}); - Object.defineProperty(ViewContainer.prototype._siblingToInsertAfter, "parameters", {get: function() { - return [[assert.type.number]]; - }}); - Object.defineProperty(ViewContainer.prototype.detach, "parameters", {get: function() { - return [[assert.type.number]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/view/element_binder", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/change_detection", "angular2/src/reflection/types", "angular2/src/facade/collection", "angular2/src/render/dom/view/proto_view"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/view/element_binder"; - var assert, - isBlank, - isPresent, - AST, - SetterFn, - List, - ListWrapper, - protoViewModule, - ElementBinder, - Event; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - }, function($__m) { - AST = $__m.AST; - }, function($__m) { - SetterFn = $__m.SetterFn; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - protoViewModule = $__m; - }], - execute: function() { - ElementBinder = (function() { - function ElementBinder() { - var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, - textNodeIndices = $__1.textNodeIndices, - contentTagSelector = $__1.contentTagSelector, - nestedProtoView = $__1.nestedProtoView, - componentId = $__1.componentId, - eventLocals = $__1.eventLocals, - localEvents = $__1.localEvents, - globalEvents = $__1.globalEvents, - parentIndex = $__1.parentIndex, - distanceToParent = $__1.distanceToParent, - propertySetters = $__1.propertySetters; - this.textNodeIndices = textNodeIndices; - this.contentTagSelector = contentTagSelector; - this.nestedProtoView = nestedProtoView; - this.componentId = componentId; - this.eventLocals = eventLocals; - this.localEvents = localEvents; - this.globalEvents = globalEvents; - this.parentIndex = parentIndex; - this.distanceToParent = distanceToParent; - this.propertySetters = propertySetters; - } - return ($traceurRuntime.createClass)(ElementBinder, { - hasStaticComponent: function() { - return isPresent(this.componentId) && isPresent(this.nestedProtoView); + setAttribute: function(element, name, value) { + throw _abstract(); }, - hasDynamicComponent: function() { - return isPresent(this.componentId) && isBlank(this.nestedProtoView); - } - }, {}); - }()); - $__export("ElementBinder", ElementBinder); - Event = (function() { - function Event(name, target, fullName) { - assert.argumentTypes(name, assert.type.string, target, assert.type.string, fullName, assert.type.string); - this.name = name; - this.target = target; - this.fullName = fullName; - } - return ($traceurRuntime.createClass)(Event, {}, {}); - }()); - $__export("Event", Event); - Object.defineProperty(Event, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/util", ["rtts_assert/rtts_assert", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/util"; - var assert, - StringWrapper, - RegExpWrapper, - isPresent, - NG_BINDING_CLASS_SELECTOR, - NG_BINDING_CLASS, - EVENT_TARGET_SEPARATOR, - CAMEL_CASE_REGEXP, - DASH_CASE_REGEXP; - function camelCaseToDashCase(input) { - assert.argumentTypes(input, assert.type.string); - return StringWrapper.replaceAllMapped(input, CAMEL_CASE_REGEXP, (function(m) { - return '-' + m[1].toLowerCase(); - })); - } - function dashCaseToCamelCase(input) { - assert.argumentTypes(input, assert.type.string); - return StringWrapper.replaceAllMapped(input, DASH_CASE_REGEXP, (function(m) { - return m[1].toUpperCase(); - })); - } - $__export("camelCaseToDashCase", camelCaseToDashCase); - $__export("dashCaseToCamelCase", dashCaseToCamelCase); - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - StringWrapper = $__m.StringWrapper; - RegExpWrapper = $__m.RegExpWrapper; - isPresent = $__m.isPresent; - }], - execute: function() { - NG_BINDING_CLASS_SELECTOR = '.ng-binding'; - $__export("NG_BINDING_CLASS_SELECTOR", NG_BINDING_CLASS_SELECTOR); - NG_BINDING_CLASS = 'ng-binding'; - $__export("NG_BINDING_CLASS", NG_BINDING_CLASS); - EVENT_TARGET_SEPARATOR = ':'; - $__export("EVENT_TARGET_SEPARATOR", EVENT_TARGET_SEPARATOR); - CAMEL_CASE_REGEXP = RegExpWrapper.create('([A-Z])'); - DASH_CASE_REGEXP = RegExpWrapper.create('-([a-z])'); - Object.defineProperty(camelCaseToDashCase, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(dashCaseToCamelCase, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/shadow_dom/content_tag", ["rtts_assert/rtts_assert", "angular2/src/render/dom/shadow_dom/light_dom", "angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/content_tag"; - var assert, - ldModule, - DOM, - isPresent, - List, - ListWrapper, - ContentStrategy, - RenderedContent, - IntermediateContent, - Content; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - ldModule = $__m; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }], - execute: function() { - ContentStrategy = (function() { - function ContentStrategy() {} - return ($traceurRuntime.createClass)(ContentStrategy, {insert: function(nodes) { - assert.argumentTypes(nodes, List); - }}, {}); - }()); - Object.defineProperty(ContentStrategy.prototype.insert, "parameters", {get: function() { - return [[List]]; - }}); - RenderedContent = (function($__super) { - function RenderedContent(contentEl) { - $traceurRuntime.superConstructor(RenderedContent).call(this); - this.beginScript = contentEl; - this.endScript = DOM.nextSibling(this.beginScript); - this.nodes = []; - } - return ($traceurRuntime.createClass)(RenderedContent, { - insert: function(nodes) { - assert.argumentTypes(nodes, List); - this.nodes = nodes; - DOM.insertAllBefore(this.endScript, nodes); - this._removeNodesUntil(ListWrapper.isEmpty(nodes) ? this.endScript : nodes[0]); + removeAttribute: function(element, attribute) { + throw _abstract(); }, - _removeNodesUntil: function(node) { - var p = DOM.parentElement(this.beginScript); - for (var next = DOM.nextSibling(this.beginScript); next !== node; next = DOM.nextSibling(this.beginScript)) { - DOM.removeChild(p, next); - } - } - }, {}, $__super); - }(ContentStrategy)); - Object.defineProperty(RenderedContent.prototype.insert, "parameters", {get: function() { - return [[List]]; - }}); - IntermediateContent = (function($__super) { - function IntermediateContent(destinationLightDom) { - assert.argumentTypes(destinationLightDom, ldModule.LightDom); - $traceurRuntime.superConstructor(IntermediateContent).call(this); - this.nodes = []; - this.destinationLightDom = destinationLightDom; - } - return ($traceurRuntime.createClass)(IntermediateContent, {insert: function(nodes) { - assert.argumentTypes(nodes, List); - this.nodes = nodes; - this.destinationLightDom.redistribute(); - }}, {}, $__super); - }(ContentStrategy)); - Object.defineProperty(IntermediateContent, "parameters", {get: function() { - return [[ldModule.LightDom]]; - }}); - Object.defineProperty(IntermediateContent.prototype.insert, "parameters", {get: function() { - return [[List]]; - }}); - Content = (function() { - function Content(contentStartEl, selector) { - assert.argumentTypes(contentStartEl, assert.type.any, selector, assert.type.string); - this.select = selector; - this.contentStartElement = contentStartEl; - this._strategy = null; - } - return ($traceurRuntime.createClass)(Content, { - hydrate: function(destinationLightDom) { - assert.argumentTypes(destinationLightDom, ldModule.LightDom); - this._strategy = isPresent(destinationLightDom) ? new IntermediateContent(destinationLightDom) : new RenderedContent(this.contentStartElement); + templateAwareRoot: function(el) { + throw _abstract(); }, - dehydrate: function() { - this._strategy = null; + createHtmlDocument: function() { + throw _abstract(); }, - nodes: function() { - return assert.returnType((this._strategy.nodes), List); + defaultDoc: function() { + throw _abstract(); }, - insert: function(nodes) { - assert.argumentTypes(nodes, List); - this._strategy.insert(nodes); - } - }, {}); - }()); - $__export("Content", Content); - Object.defineProperty(Content, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(Content.prototype.hydrate, "parameters", {get: function() { - return [[ldModule.LightDom]]; - }}); - Object.defineProperty(Content.prototype.insert, "parameters", {get: function() { - return [[List]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/shadow_dom/shadow_dom_strategy", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/light_dom"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"; - var assert, - isBlank, - isPresent, - Promise, - viewModule, - LightDom, - ShadowDomStrategy; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - }, function($__m) { - Promise = $__m.Promise; - }, function($__m) { - viewModule = $__m; - }, function($__m) { - LightDom = $__m.LightDom; - }], - execute: function() { - ShadowDomStrategy = (function() { - function ShadowDomStrategy() {} - return ($traceurRuntime.createClass)(ShadowDomStrategy, { - hasNativeContentElement: function() { - return assert.returnType((true), assert.type.boolean); + getBoundingClientRect: function(el) { + throw _abstract(); }, - attachTemplate: function(el, view) { - assert.argumentTypes(el, assert.type.any, view, viewModule.RenderView); + getTitle: function() { + throw _abstract(); }, - constructLightDom: function(lightDomView, shadowDomView, el) { - assert.argumentTypes(lightDomView, viewModule.RenderView, shadowDomView, viewModule.RenderView, el, assert.type.any); - return assert.returnType((null), LightDom); + setTitle: function(newTitle) { + throw _abstract(); }, - processStyleElement: function(hostComponentId, templateUrl, styleElement) { - assert.argumentTypes(hostComponentId, assert.type.string, templateUrl, assert.type.string, styleElement, assert.type.any); - return assert.returnType((null), Promise); + elementMatches: function(n, selector) { + throw _abstract(); }, - processElement: function(hostComponentId, elementComponentId, element) { - assert.argumentTypes(hostComponentId, assert.type.string, elementComponentId, assert.type.string, element, assert.type.any); - } - }, {}); - }()); - $__export("ShadowDomStrategy", ShadowDomStrategy); - Object.defineProperty(ShadowDomStrategy.prototype.attachTemplate, "parameters", {get: function() { - return [[], [viewModule.RenderView]]; - }}); - Object.defineProperty(ShadowDomStrategy.prototype.constructLightDom, "parameters", {get: function() { - return [[viewModule.RenderView], [viewModule.RenderView], []]; - }}); - Object.defineProperty(ShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; - }}); - Object.defineProperty(ShadowDomStrategy.prototype.processElement, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; - }}); - } - }; -}); - -System.register("angular2/src/core/zone/vm_turn_zone", ["angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/zone/vm_turn_zone"; - var List, - ListWrapper, - StringMapWrapper, - normalizeBlank, - isPresent, - global, - VmTurnZone; - return { - setters: [function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - StringMapWrapper = $__m.StringMapWrapper; - }, function($__m) { - normalizeBlank = $__m.normalizeBlank; - isPresent = $__m.isPresent; - global = $__m.global; - }], - execute: function() { - VmTurnZone = (function() { - function VmTurnZone($__2) { - var enableLongStackTrace = $__2.enableLongStackTrace; - this._nestedRunCounter = 0; - this._onTurnStart = null; - this._onTurnDone = null; - this._onErrorHandler = null; - this._outerZone = global.zone; - this._innerZone = this._createInnerZone(this._outerZone, enableLongStackTrace); - } - return ($traceurRuntime.createClass)(VmTurnZone, { - initCallbacks: function() { - var $__2 = arguments[0] !== (void 0) ? arguments[0] : {}, - onTurnStart = $__2.onTurnStart, - onTurnDone = $__2.onTurnDone, - onScheduleMicrotask = $__2.onScheduleMicrotask, - onErrorHandler = $__2.onErrorHandler; - this._onTurnStart = normalizeBlank(onTurnStart); - this._onTurnDone = normalizeBlank(onTurnDone); - this._onErrorHandler = normalizeBlank(onErrorHandler); + isTemplateElement: function(el) { + throw _abstract(); }, - run: function(fn) { - return this._innerZone.run(fn); + isTextNode: function(node) { + throw _abstract(); }, - runOutsideAngular: function(fn) { - return this._outerZone.run(fn); + isCommentNode: function(node) { + throw _abstract(); }, - _createInnerZone: function(zone, enableLongStackTrace) { - var $__0 = this; - var vmTurnZone = this; - var errorHandling; - if (enableLongStackTrace) { - errorHandling = StringMapWrapper.merge(Zone.longStackTraceZone, {onError: function(e) { - vmTurnZone._onError(this, e); - }}); - } else { - errorHandling = {onError: function(e) { - vmTurnZone._onError(this, e); - }}; - } - return zone.fork(errorHandling).fork({ - beforeTask: (function() { - $__0._beforeTask(); - }), - afterTask: (function() { - $__0._afterTask(); - }) - }); + isElementNode: function(node) { + throw _abstract(); }, - _beforeTask: function() { - this._nestedRunCounter++; - if (this._nestedRunCounter === 1 && this._onTurnStart) { - this._onTurnStart(); - } + hasShadowRoot: function(node) { + throw _abstract(); }, - _afterTask: function() { - this._nestedRunCounter--; - if (this._nestedRunCounter === 0 && this._onTurnDone) { - this._onTurnDone(); - } + isShadowRoot: function(node) { + throw _abstract(); }, - _onError: function(zone, e) { - if (isPresent(this._onErrorHandler)) { - var trace = [normalizeBlank(e.stack)]; - while (zone && zone.constructedAtException) { - trace.push(zone.constructedAtException.get()); - zone = zone.parent; - } - this._onErrorHandler(e, trace); - } else { - throw e; - } - } - }, {}); - }()); - $__export("VmTurnZone", VmTurnZone); - } - }; -}); - -System.register("angular2/src/render/dom/view/view_hydrator", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/render/dom/shadow_dom/light_dom", "angular2/src/render/dom/events/event_manager", "angular2/src/render/dom/view/view_factory", "angular2/src/render/dom/view/view_container", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/view/view_hydrator"; - var assert, - Injectable, - int, - isPresent, - isBlank, - BaseException, - ListWrapper, - MapWrapper, - Map, - StringMapWrapper, - List, - ldModule, - EventManager, - ViewFactory, - vcModule, - viewModule, - ShadowDomStrategy, - RenderViewHydrator; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { - int = $__m.int; - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - Map = $__m.Map; - StringMapWrapper = $__m.StringMapWrapper; - List = $__m.List; - }, function($__m) { - ldModule = $__m; - }, function($__m) { - EventManager = $__m.EventManager; - }, function($__m) { - ViewFactory = $__m.ViewFactory; - }, function($__m) { - vcModule = $__m; - }, function($__m) { - viewModule = $__m; - }, function($__m) { - ShadowDomStrategy = $__m.ShadowDomStrategy; - }], - execute: function() { - RenderViewHydrator = (function() { - function RenderViewHydrator(eventManager, viewFactory, shadowDomStrategy) { - assert.argumentTypes(eventManager, EventManager, viewFactory, ViewFactory, shadowDomStrategy, ShadowDomStrategy); - this._eventManager = eventManager; - this._viewFactory = viewFactory; - this._shadowDomStrategy = shadowDomStrategy; - } - return ($traceurRuntime.createClass)(RenderViewHydrator, { - hydrateDynamicComponentView: function(hostView, boundElementIndex, componentView) { - assert.argumentTypes(hostView, viewModule.RenderView, boundElementIndex, assert.type.number, componentView, viewModule.RenderView); - ViewFactory.setComponentView(this._shadowDomStrategy, hostView, boundElementIndex, componentView); - var lightDom = hostView.lightDoms[boundElementIndex]; - this._viewHydrateRecurse(componentView, lightDom); - if (isPresent(lightDom)) { - lightDom.redistribute(); - } + importIntoDoc: function(node) { + throw _abstract(); }, - dehydrateDynamicComponentView: function(parentView, boundElementIndex) { - assert.argumentTypes(parentView, viewModule.RenderView, boundElementIndex, assert.type.number); - throw new BaseException('Not supported yet'); + isPageRule: function(rule) { + throw _abstract(); }, - hydrateInPlaceHostView: function(parentView, hostView) { - assert.argumentTypes(parentView, viewModule.RenderView, hostView, viewModule.RenderView); - if (isPresent(parentView)) { - ListWrapper.push(parentView.imperativeHostViews, hostView); - } - this._viewHydrateRecurse(hostView, null); + isStyleRule: function(rule) { + throw _abstract(); }, - dehydrateInPlaceHostView: function(parentView, hostView) { - assert.argumentTypes(parentView, viewModule.RenderView, hostView, viewModule.RenderView); - if (isPresent(parentView)) { - ListWrapper.remove(parentView.imperativeHostViews, hostView); - } - vcModule.ViewContainer.removeViewNodes(hostView); - hostView.rootNodes = []; - this._viewDehydrateRecurse(hostView); + isMediaRule: function(rule) { + throw _abstract(); }, - hydrateViewInViewContainer: function(viewContainer, view) { - assert.argumentTypes(viewContainer, vcModule.ViewContainer, view, viewModule.RenderView); - this._viewHydrateRecurse(view, viewContainer.parentView.hostLightDom); + isKeyframesRule: function(rule) { + throw _abstract(); }, - dehydrateViewInViewContainer: function(viewContainer, view) { - assert.argumentTypes(viewContainer, vcModule.ViewContainer, view, viewModule.RenderView); - this._viewDehydrateRecurse(view); + getHref: function(element) { + throw _abstract(); }, - _viewHydrateRecurse: function(view, hostLightDom) { - assert.argumentTypes(view, assert.type.any, hostLightDom, ldModule.LightDom); - if (view.hydrated) - throw new BaseException('The view is already hydrated.'); - view.hydrated = true; - view.hostLightDom = hostLightDom; - for (var i = 0; i < view.contentTags.length; i++) { - var destLightDom = view.getDirectParentLightDom(i); - var ct = view.contentTags[i]; - if (isPresent(ct)) { - ct.hydrate(destLightDom); - } - } - for (var i = 0; i < view.componentChildViews.length; i++) { - var cv = view.componentChildViews[i]; - if (isPresent(cv)) { - this._viewHydrateRecurse(cv, view.lightDoms[i]); - } - } - for (var i = 0; i < view.lightDoms.length; ++i) { - var lightDom = view.lightDoms[i]; - if (isPresent(lightDom)) { - lightDom.redistribute(); - } - } - view.eventHandlerRemovers = ListWrapper.create(); - var binders = view.proto.elementBinders; - for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { - var binder = binders[binderIdx]; - if (isPresent(binder.globalEvents)) { - for (var i = 0; i < binder.globalEvents.length; i++) { - var globalEvent = binder.globalEvents[i]; - var remover = this._createGlobalEventListener(view, binderIdx, globalEvent.name, globalEvent.target, globalEvent.fullName); - ListWrapper.push(view.eventHandlerRemovers, remover); - } - } - } + getEventKey: function(event) { + throw _abstract(); }, - _createGlobalEventListener: function(view, elementIndex, eventName, eventTarget, fullName) { - return assert.returnType((this._eventManager.addGlobalEventListener(eventTarget, eventName, (function(event) { - view.dispatchEvent(elementIndex, fullName, event); - }))), Function); - }, - _viewDehydrateRecurse: function(view) { - for (var i = 0; i < view.componentChildViews.length; i++) { - var cv = view.componentChildViews[i]; - if (isPresent(cv)) { - this._viewDehydrateRecurse(cv); - if (view.proto.elementBinders[i].hasDynamicComponent()) { - vcModule.ViewContainer.removeViewNodes(cv); - this._viewFactory.returnView(cv); - view.lightDoms[i] = null; - view.componentChildViews[i] = null; - } - } - } - for (var i = 0; i < view.imperativeHostViews.length; i++) { - var hostView = view.imperativeHostViews[i]; - this._viewDehydrateRecurse(hostView); - vcModule.ViewContainer.removeViewNodes(hostView); - hostView.rootNodes = []; - this._viewFactory.returnView(hostView); - } - view.imperativeHostViews = []; - if (isPresent(view.viewContainers)) { - for (var i = 0; i < view.viewContainers.length; i++) { - var vc = view.viewContainers[i]; - if (isPresent(vc)) { - this._viewContainerDehydrateRecurse(vc); - } - var ct = view.contentTags[i]; - if (isPresent(ct)) { - ct.dehydrate(); - } - } - } - for (var i = 0; i < view.eventHandlerRemovers.length; i++) { - view.eventHandlerRemovers[i](); - } - view.hostLightDom = null; - view.eventHandlerRemovers = null; - view.setEventDispatcher(null); - view.hydrated = false; + resolveAndSetHref: function(element, baseUrl, href) { + throw _abstract(); }, - _viewContainerDehydrateRecurse: function(viewContainer) { - for (var i = 0; i < viewContainer.views.length; i++) { - var view = viewContainer.views[i]; - this._viewDehydrateRecurse(view); - this._viewFactory.returnView(view); - } - viewContainer.clear(); + cssToRules: function(css) { + throw _abstract(); + }, + supportsDOMEvents: function() { + throw _abstract(); + }, + supportsNativeShadowDOM: function() { + throw _abstract(); + }, + getGlobalEventTarget: function(target) { + throw _abstract(); + }, + getHistory: function() { + throw _abstract(); + }, + getLocation: function() { + throw _abstract(); + }, + getBaseHref: function() { + throw _abstract(); } }, {}); }()); - $__export("RenderViewHydrator", RenderViewHydrator); - Object.defineProperty(RenderViewHydrator, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(RenderViewHydrator, "parameters", {get: function() { - return [[EventManager], [ViewFactory], [ShadowDomStrategy]]; - }}); - Object.defineProperty(RenderViewHydrator.prototype.hydrateDynamicComponentView, "parameters", {get: function() { - return [[viewModule.RenderView], [assert.type.number], [viewModule.RenderView]]; - }}); - Object.defineProperty(RenderViewHydrator.prototype.dehydrateDynamicComponentView, "parameters", {get: function() { - return [[viewModule.RenderView], [assert.type.number]]; - }}); - Object.defineProperty(RenderViewHydrator.prototype.hydrateInPlaceHostView, "parameters", {get: function() { - return [[viewModule.RenderView], [viewModule.RenderView]]; - }}); - Object.defineProperty(RenderViewHydrator.prototype.dehydrateInPlaceHostView, "parameters", {get: function() { - return [[viewModule.RenderView], [viewModule.RenderView]]; - }}); - Object.defineProperty(RenderViewHydrator.prototype.hydrateViewInViewContainer, "parameters", {get: function() { - return [[vcModule.ViewContainer], [viewModule.RenderView]]; - }}); - Object.defineProperty(RenderViewHydrator.prototype.dehydrateViewInViewContainer, "parameters", {get: function() { - return [[vcModule.ViewContainer], [viewModule.RenderView]]; - }}); - Object.defineProperty(RenderViewHydrator.prototype._viewHydrateRecurse, "parameters", {get: function() { - return [[], [ldModule.LightDom]]; - }}); + $__export("DomAdapter", DomAdapter); } }; }); -System.register("angular2/src/render/dom/view/property_setter_factory", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/util", "angular2/src/reflection/reflection"], function($__export) { +System.register("angular2/src/dom/generic_browser_adapter", ["angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/view/property_setter_factory"; - var assert, - StringWrapper, - RegExpWrapper, - BaseException, + var __moduleName = "angular2/src/dom/generic_browser_adapter"; + var ListWrapper, isPresent, - isBlank, - isString, - stringify, - ListWrapper, - StringMapWrapper, - DOM, - camelCaseToDashCase, - dashCaseToCamelCase, - reflector, - STYLE_SEPARATOR, - propertySettersCache, - innerHTMLSetterCache, - ATTRIBUTE_PREFIX, - attributeSettersCache, - CLASS_PREFIX, - classSettersCache, - STYLE_PREFIX, - styleSettersCache; - function setterFactory(property) { - var setterFn, - styleParts, - styleSuffix; - if (StringWrapper.startsWith(property, ATTRIBUTE_PREFIX)) { - setterFn = attributeSetterFactory(StringWrapper.substring(property, ATTRIBUTE_PREFIX.length)); - } else if (StringWrapper.startsWith(property, CLASS_PREFIX)) { - setterFn = classSetterFactory(StringWrapper.substring(property, CLASS_PREFIX.length)); - } else if (StringWrapper.startsWith(property, STYLE_PREFIX)) { - styleParts = property.split(STYLE_SEPARATOR); - styleSuffix = styleParts.length > 2 ? ListWrapper.get(styleParts, 2) : ''; - setterFn = styleSetterFactory(ListWrapper.get(styleParts, 1), styleSuffix); - } else if (StringWrapper.equals(property, 'innerHtml')) { - if (isBlank(innerHTMLSetterCache)) { - innerHTMLSetterCache = (function(el, value) { - return DOM.setInnerHTML(el, value); - }); - } - setterFn = innerHTMLSetterCache; - } else { - property = resolvePropertyName(property); - setterFn = StringMapWrapper.get(propertySettersCache, property); - if (isBlank(setterFn)) { - var propertySetterFn = reflector.setter(property); - setterFn = function(receiver, value) { - if (DOM.hasProperty(receiver, property)) { - return propertySetterFn(receiver, value); - } - }; - StringMapWrapper.set(propertySettersCache, property, setterFn); - } - } - return assert.returnType((setterFn), Function); - } - function _isValidAttributeValue(attrName, value) { - assert.argumentTypes(attrName, assert.type.string, value, assert.type.any); - if (attrName == "role") { - return assert.returnType((isString(value)), assert.type.boolean); - } else { - return assert.returnType((isPresent(value)), assert.type.boolean); - } - } - function attributeSetterFactory(attrName) { - assert.argumentTypes(attrName, assert.type.string); - var setterFn = StringMapWrapper.get(attributeSettersCache, attrName); - var dashCasedAttributeName; - if (isBlank(setterFn)) { - dashCasedAttributeName = camelCaseToDashCase(attrName); - setterFn = function(element, value) { - if (_isValidAttributeValue(dashCasedAttributeName, value)) { - DOM.setAttribute(element, dashCasedAttributeName, stringify(value)); - } else { - if (isPresent(value)) { - throw new BaseException("Invalid " + dashCasedAttributeName + " attribute, only string values are allowed, got '" + stringify(value) + "'"); - } - DOM.removeAttribute(element, dashCasedAttributeName); - } - }; - StringMapWrapper.set(attributeSettersCache, attrName, setterFn); - } - return assert.returnType((setterFn), Function); - } - function classSetterFactory(className) { - assert.argumentTypes(className, assert.type.string); - var setterFn = StringMapWrapper.get(classSettersCache, className); - var dashCasedClassName; - if (isBlank(setterFn)) { - dashCasedClassName = camelCaseToDashCase(className); - setterFn = function(element, value) { - if (value) { - DOM.addClass(element, dashCasedClassName); - } else { - DOM.removeClass(element, dashCasedClassName); - } - }; - StringMapWrapper.set(classSettersCache, className, setterFn); - } - return assert.returnType((setterFn), Function); - } - function styleSetterFactory(styleName, styleSuffix) { - assert.argumentTypes(styleName, assert.type.string, styleSuffix, assert.type.string); - var cacheKey = styleName + styleSuffix; - var setterFn = StringMapWrapper.get(styleSettersCache, cacheKey); - var dashCasedStyleName; - if (isBlank(setterFn)) { - dashCasedStyleName = camelCaseToDashCase(styleName); - setterFn = function(element, value) { - var valAsStr; - if (isPresent(value)) { - valAsStr = stringify(value); - DOM.setStyle(element, dashCasedStyleName, valAsStr + styleSuffix); - } else { - DOM.removeStyle(element, dashCasedStyleName); - } - }; - StringMapWrapper.set(styleSettersCache, cacheKey, setterFn); - } - return assert.returnType((setterFn), Function); - } - function resolvePropertyName(attrName) { - assert.argumentTypes(attrName, assert.type.string); - var mappedPropName = StringMapWrapper.get(DOM.attrToPropMap, attrName); - return assert.returnType((isPresent(mappedPropName) ? mappedPropName : attrName), assert.type.string); - } - $__export("setterFactory", setterFactory); + isFunction, + DomAdapter, + GenericBrowserDomAdapter; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - StringWrapper = $__m.StringWrapper; - RegExpWrapper = $__m.RegExpWrapper; - BaseException = $__m.BaseException; - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - isString = $__m.isString; - stringify = $__m.stringify; - }, function($__m) { ListWrapper = $__m.ListWrapper; - StringMapWrapper = $__m.StringMapWrapper; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - camelCaseToDashCase = $__m.camelCaseToDashCase; - dashCaseToCamelCase = $__m.dashCaseToCamelCase; - }, function($__m) { - reflector = $__m.reflector; - }], - execute: function() { - STYLE_SEPARATOR = '.'; - propertySettersCache = StringMapWrapper.create(); - Object.defineProperty(setterFactory, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - ATTRIBUTE_PREFIX = 'attr.'; - attributeSettersCache = StringMapWrapper.create(); - Object.defineProperty(_isValidAttributeValue, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(attributeSetterFactory, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - CLASS_PREFIX = 'class.'; - classSettersCache = StringMapWrapper.create(); - Object.defineProperty(classSetterFactory, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - STYLE_PREFIX = 'style.'; - styleSettersCache = StringMapWrapper.create(); - Object.defineProperty(styleSetterFactory, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(resolvePropertyName, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/compiler/compile_step", ["rtts_assert/rtts_assert", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/compile_step"; - var assert, - CompileElement, - compileControlModule, - CompileStep; - return { - setters: [function($__m) { - assert = $__m.assert; }, function($__m) { - CompileElement = $__m.CompileElement; - }, function($__m) { - compileControlModule = $__m; - }], - execute: function() { - CompileStep = (function() { - function CompileStep() {} - return ($traceurRuntime.createClass)(CompileStep, {process: function(parent, current, control) { - assert.argumentTypes(parent, CompileElement, current, CompileElement, control, compileControlModule.CompileControl); - }}, {}); - }()); - $__export("CompileStep", CompileStep); - Object.defineProperty(CompileStep.prototype.process, "parameters", {get: function() { - return [[CompileElement], [CompileElement], [compileControlModule.CompileControl]]; - }}); - } - }; -}); - -System.register("angular2/src/services/xhr", ["rtts_assert/rtts_assert", "angular2/src/facade/async"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/services/xhr"; - var assert, - Promise, - XHR; - return { - setters: [function($__m) { - assert = $__m.assert; + isPresent = $__m.isPresent; + isFunction = $__m.isFunction; }, function($__m) { - Promise = $__m.Promise; + DomAdapter = $__m.DomAdapter; }], execute: function() { - XHR = (function() { - function XHR() {} - return ($traceurRuntime.createClass)(XHR, {get: function(url) { - assert.argumentTypes(url, assert.type.string); - return assert.returnType((null), assert.genericType(Promise, assert.type.string)); - }}, {}); - }()); - $__export("XHR", XHR); - Object.defineProperty(XHR.prototype.get, "parameters", {get: function() { - return [[assert.type.string]]; - }}); + GenericBrowserDomAdapter = (function($__super) { + function GenericBrowserDomAdapter() { + $traceurRuntime.superConstructor(GenericBrowserDomAdapter).apply(this, arguments); + } + return ($traceurRuntime.createClass)(GenericBrowserDomAdapter, { + getDistributedNodes: function(el) { + return el.getDistributedNodes(); + }, + resolveAndSetHref: function(el, baseUrl, href) { + el.href = href == null ? baseUrl : baseUrl + '/../' + href; + }, + cssToRules: function(css) { + var style = this.createStyleElement(css); + this.appendChild(this.defaultDoc().head, style); + var rules = ListWrapper.create(); + if (isPresent(style.sheet)) { + try { + var rawRules = style.sheet.cssRules; + rules = ListWrapper.createFixedSize(rawRules.length); + for (var i = 0; i < rawRules.length; i++) { + rules[i] = rawRules[i]; + } + } catch (e) {} + } else {} + this.remove(style); + return rules; + }, + supportsDOMEvents: function() { + return true; + }, + supportsNativeShadowDOM: function() { + return isFunction(this.defaultDoc().body.createShadowRoot); + } + }, {}, $__super); + }(DomAdapter)); + $__export("GenericBrowserDomAdapter", GenericBrowserDomAdapter); } }; }); -System.register("angular2/src/services/url_resolver", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter"], function($__export) { +System.register("angular2/src/core/annotations_impl/annotations", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/di/annotations_impl", "angular2/change_detection"], function($__export) { "use strict"; - var __moduleName = "angular2/src/services/url_resolver"; - var assert, - Injectable, + var __moduleName = "angular2/src/core/annotations_impl/annotations"; + var CONST, + normalizeBlank, isPresent, - isBlank, - RegExpWrapper, - BaseException, - DOM, - UrlResolver, - _schemeRe; + ListWrapper, + List, + Injectable, + DEFAULT, + Directive, + Component, + onDestroy, + onChange, + onAllChangesDone; return { setters: [function($__m) { - assert = $__m.assert; + CONST = $__m.CONST; + normalizeBlank = $__m.normalizeBlank; + isPresent = $__m.isPresent; }, function($__m) { - Injectable = $__m.Injectable; + ListWrapper = $__m.ListWrapper; + List = $__m.List; }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - RegExpWrapper = $__m.RegExpWrapper; - BaseException = $__m.BaseException; + Injectable = $__m.Injectable; }, function($__m) { - DOM = $__m.DOM; + DEFAULT = $__m.DEFAULT; }], execute: function() { - UrlResolver = (function() { - function UrlResolver() { - if (isBlank(UrlResolver.a)) { - UrlResolver.a = DOM.createElement('a'); - } + Directive = (function($__super) { + function Directive() { + var $__2; + var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, + selector = $__1.selector, + properties = $__1.properties, + events = $__1.events, + hostListeners = $__1.hostListeners, + hostProperties = $__1.hostProperties, + hostAttributes = $__1.hostAttributes, + hostActions = $__1.hostActions, + lifecycle = $__1.lifecycle, + compileChildren = ($__2 = $__1.compileChildren) === void 0 ? true : $__2; + $traceurRuntime.superConstructor(Directive).call(this); + this.selector = selector; + this.properties = properties; + this.events = events; + this.hostListeners = hostListeners; + this.hostProperties = hostProperties; + this.hostAttributes = hostAttributes; + this.hostActions = hostActions; + this.lifecycle = lifecycle; + this.compileChildren = compileChildren; } - return ($traceurRuntime.createClass)(UrlResolver, {resolve: function(baseUrl, url) { - assert.argumentTypes(baseUrl, assert.type.string, url, assert.type.string); - if (isBlank(baseUrl)) { - DOM.resolveAndSetHref(UrlResolver.a, url, null); - return assert.returnType((DOM.getHref(UrlResolver.a)), assert.type.string); - } - if (isBlank(url) || url == '') - return assert.returnType((baseUrl), assert.type.string); - if (url[0] == '/') { - throw new BaseException(("Could not resolve the url " + url + " from " + baseUrl)); - } - var m = RegExpWrapper.firstMatch(_schemeRe, url); - if (isPresent(m[1])) { - return assert.returnType((url), assert.type.string); - } - DOM.resolveAndSetHref(UrlResolver.a, baseUrl, url); - return assert.returnType((DOM.getHref(UrlResolver.a)), assert.type.string); - }}, {}); - }()); - $__export("UrlResolver", UrlResolver); - Object.defineProperty(UrlResolver, "annotations", {get: function() { - return [new Injectable()]; + return ($traceurRuntime.createClass)(Directive, {hasLifecycleHook: function(hook) { + return isPresent(this.lifecycle) ? ListWrapper.contains(this.lifecycle, hook) : false; + }}, {}, $__super); + }(Injectable)); + $__export("Directive", Directive); + Object.defineProperty(Directive, "annotations", {get: function() { + return [new CONST()]; }}); - Object.defineProperty(UrlResolver.prototype.resolve, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; + Object.defineProperty(Directive.prototype.hasLifecycleHook, "parameters", {get: function() { + return [[assert.type.string]]; }}); - _schemeRe = RegExpWrapper.create('^([^:/?#]+:)?'); + Component = (function($__super) { + function Component() { + var $__2, + $__3; + var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, + selector = $__1.selector, + properties = $__1.properties, + events = $__1.events, + hostListeners = $__1.hostListeners, + hostProperties = $__1.hostProperties, + hostAttributes = $__1.hostAttributes, + hostActions = $__1.hostActions, + injectables = $__1.injectables, + lifecycle = $__1.lifecycle, + changeDetection = ($__2 = $__1.changeDetection) === void 0 ? DEFAULT : $__2, + compileChildren = ($__3 = $__1.compileChildren) === void 0 ? true : $__3, + publishAs = $__1.publishAs; + $traceurRuntime.superConstructor(Component).call(this, { + selector: selector, + properties: properties, + events: events, + hostListeners: hostListeners, + hostProperties: hostProperties, + hostAttributes: hostAttributes, + hostActions: hostActions, + lifecycle: lifecycle, + compileChildren: compileChildren + }); + this.changeDetection = changeDetection; + this.injectables = injectables; + this.publishAs = publishAs; + } + return ($traceurRuntime.createClass)(Component, {}, {}, $__super); + }(Directive)); + $__export("Component", Component); + Object.defineProperty(Component, "annotations", {get: function() { + return [new CONST()]; + }}); + onDestroy = "onDestroy"; + $__export("onDestroy", onDestroy); + onChange = "onChange"; + $__export("onChange", onChange); + onAllChangesDone = "onAllChangesDone"; + $__export("onAllChangesDone", onAllChangesDone); } }; }); -System.register("angular2/src/render/dom/compiler/property_binding_parser", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/change_detection", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/dom/util"], function($__export) { +System.register("angular2/src/core/compiler/directive_metadata", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/core/annotations_impl/annotations", "angular2/di"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/property_binding_parser"; - var assert, - isPresent, - RegExpWrapper, - MapWrapper, - Parser, - CompileStep, - CompileElement, - CompileControl, - dashCaseToCamelCase, - BIND_NAME_REGEXP, - PropertyBindingParser; + var __moduleName = "angular2/src/core/compiler/directive_metadata"; + var Type, + List, + Directive, + ResolvedBinding, + DirectiveMetadata; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - RegExpWrapper = $__m.RegExpWrapper; - }, function($__m) { - MapWrapper = $__m.MapWrapper; - }, function($__m) { - Parser = $__m.Parser; - }, function($__m) { - CompileStep = $__m.CompileStep; + Type = $__m.Type; }, function($__m) { - CompileElement = $__m.CompileElement; + List = $__m.List; }, function($__m) { - CompileControl = $__m.CompileControl; + Directive = $__m.Directive; }, function($__m) { - dashCaseToCamelCase = $__m.dashCaseToCamelCase; + ResolvedBinding = $__m.ResolvedBinding; }], execute: function() { - BIND_NAME_REGEXP = RegExpWrapper.create('^(?:(?:(?:(bind-)|(var-|#)|(on-))(.+))|\\[([^\\]]+)\\]|\\(([^\\)]+)\\))$'); - PropertyBindingParser = (function($__super) { - function PropertyBindingParser(parser) { - assert.argumentTypes(parser, Parser); - $traceurRuntime.superConstructor(PropertyBindingParser).call(this); - this._parser = parser; + DirectiveMetadata = (function() { + function DirectiveMetadata(type, annotation, resolvedInjectables) { + this.annotation = annotation; + this.type = type; + this.resolvedInjectables = resolvedInjectables; } - return ($traceurRuntime.createClass)(PropertyBindingParser, { - process: function(parent, current, control) { - var $__0 = this; - assert.argumentTypes(parent, CompileElement, current, CompileElement, control, CompileControl); - var attrs = current.attrs(); - var newAttrs = MapWrapper.create(); - MapWrapper.forEach(attrs, (function(attrValue, attrName) { - var bindParts = RegExpWrapper.firstMatch(BIND_NAME_REGEXP, attrName); - if (isPresent(bindParts)) { - if (isPresent(bindParts[1])) { - $__0._bindProperty(bindParts[4], attrValue, current, newAttrs); - } else if (isPresent(bindParts[2])) { - var identifier = bindParts[4]; - var value = attrValue == '' ? '\$implicit' : attrValue; - $__0._bindVariable(identifier, value, current, newAttrs); - } else if (isPresent(bindParts[3])) { - $__0._bindEvent(bindParts[4], attrValue, current, newAttrs); - } else if (isPresent(bindParts[5])) { - $__0._bindProperty(bindParts[5], attrValue, current, newAttrs); - } else if (isPresent(bindParts[6])) { - $__0._bindEvent(bindParts[6], attrValue, current, newAttrs); - } - } else { - var expr = $__0._parser.parseInterpolation(attrValue, current.elementDescription); - if (isPresent(expr)) { - $__0._bindPropertyAst(attrName, expr, current, newAttrs); - } - } - })); - MapWrapper.forEach(newAttrs, (function(attrValue, attrName) { - MapWrapper.set(attrs, attrName, attrValue); - })); - }, - _bindVariable: function(identifier, value, current, newAttrs) { - assert.argumentTypes(identifier, assert.type.any, value, assert.type.any, current, CompileElement, newAttrs, assert.type.any); - current.bindElement().bindVariable(dashCaseToCamelCase(identifier), value); - MapWrapper.set(newAttrs, identifier, value); - }, - _bindProperty: function(name, expression, current, newAttrs) { - assert.argumentTypes(name, assert.type.any, expression, assert.type.any, current, CompileElement, newAttrs, assert.type.any); - this._bindPropertyAst(name, this._parser.parseBinding(expression, current.elementDescription), current, newAttrs); - }, - _bindPropertyAst: function(name, ast, current, newAttrs) { - assert.argumentTypes(name, assert.type.any, ast, assert.type.any, current, CompileElement, newAttrs, assert.type.any); - var binder = current.bindElement(); - var camelCaseName = dashCaseToCamelCase(name); - binder.bindProperty(camelCaseName, ast); - MapWrapper.set(newAttrs, name, ast.source); - }, - _bindEvent: function(name, expression, current, newAttrs) { - assert.argumentTypes(name, assert.type.any, expression, assert.type.any, current, CompileElement, newAttrs, assert.type.any); - current.bindElement().bindEvent(dashCaseToCamelCase(name), this._parser.parseAction(expression, current.elementDescription)); - } - }, {}, $__super); - }(CompileStep)); - $__export("PropertyBindingParser", PropertyBindingParser); - Object.defineProperty(PropertyBindingParser, "parameters", {get: function() { - return [[Parser]]; - }}); - Object.defineProperty(PropertyBindingParser.prototype.process, "parameters", {get: function() { - return [[CompileElement], [CompileElement], [CompileControl]]; - }}); - Object.defineProperty(PropertyBindingParser.prototype._bindVariable, "parameters", {get: function() { - return [[], [], [CompileElement], []]; - }}); - Object.defineProperty(PropertyBindingParser.prototype._bindProperty, "parameters", {get: function() { - return [[], [], [CompileElement], []]; - }}); - Object.defineProperty(PropertyBindingParser.prototype._bindPropertyAst, "parameters", {get: function() { - return [[], [], [CompileElement], []]; - }}); - Object.defineProperty(PropertyBindingParser.prototype._bindEvent, "parameters", {get: function() { - return [[], [], [CompileElement], []]; + return ($traceurRuntime.createClass)(DirectiveMetadata, {}, {}); + }()); + $__export("DirectiveMetadata", DirectiveMetadata); + Object.defineProperty(DirectiveMetadata, "parameters", {get: function() { + return [[Type], [Directive], [assert.genericType(List, ResolvedBinding)]]; }}); } }; }); -System.register("angular2/src/render/dom/compiler/text_interpolation_parser", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/change_detection", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control"], function($__export) { +System.register("angular2/src/facade/math", ["angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/facade/math"; + var global, + __esModule, + Math, + NaN; + return { + setters: [function($__m) { + global = $__m.global; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + Math = global.Math; + $__export("Math", Math); + NaN = typeof NaN; + $__export("NaN", NaN); + } + }; +}); + +System.register("angular2/src/core/annotations_impl/di", ["angular2/src/facade/lang", "angular2/src/di/annotations_impl"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/text_interpolation_parser"; - var assert, - RegExpWrapper, - StringWrapper, - isPresent, - DOM, - Parser, - CompileStep, - CompileElement, - CompileControl, - TextInterpolationParser; + var __moduleName = "angular2/src/core/annotations_impl/di"; + var CONST, + DependencyAnnotation, + Attribute, + Query; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - RegExpWrapper = $__m.RegExpWrapper; - StringWrapper = $__m.StringWrapper; - isPresent = $__m.isPresent; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - Parser = $__m.Parser; - }, function($__m) { - CompileStep = $__m.CompileStep; - }, function($__m) { - CompileElement = $__m.CompileElement; + CONST = $__m.CONST; }, function($__m) { - CompileControl = $__m.CompileControl; + DependencyAnnotation = $__m.DependencyAnnotation; }], execute: function() { - TextInterpolationParser = (function($__super) { - function TextInterpolationParser(parser) { - assert.argumentTypes(parser, Parser); - $traceurRuntime.superConstructor(TextInterpolationParser).call(this); - this._parser = parser; + Attribute = (function($__super) { + function Attribute(attributeName) { + $traceurRuntime.superConstructor(Attribute).call(this); + this.attributeName = attributeName; } - return ($traceurRuntime.createClass)(TextInterpolationParser, {process: function(parent, current, control) { - assert.argumentTypes(parent, CompileElement, current, CompileElement, control, CompileControl); - if (!current.compileChildren) { - return ; - } - var element = current.element; - var childNodes = DOM.childNodes(DOM.templateAwareRoot(element)); - for (var i = 0; i < childNodes.length; i++) { - var node = childNodes[i]; - if (DOM.isTextNode(node)) { - var text = DOM.nodeValue(node); - var expr = this._parser.parseInterpolation(text, current.elementDescription); - if (isPresent(expr)) { - DOM.setText(node, ' '); - current.bindElement().bindText(i, expr); - } - } - } + return ($traceurRuntime.createClass)(Attribute, {get token() { + return this; }}, {}, $__super); - }(CompileStep)); - $__export("TextInterpolationParser", TextInterpolationParser); - Object.defineProperty(TextInterpolationParser, "parameters", {get: function() { - return [[Parser]]; + }(DependencyAnnotation)); + $__export("Attribute", Attribute); + Object.defineProperty(Attribute, "annotations", {get: function() { + return [new CONST()]; }}); - Object.defineProperty(TextInterpolationParser.prototype.process, "parameters", {get: function() { - return [[CompileElement], [CompileElement], [CompileControl]]; + Query = (function($__super) { + function Query(directive) { + $traceurRuntime.superConstructor(Query).call(this); + this.directive = directive; + } + return ($traceurRuntime.createClass)(Query, {}, {}, $__super); + }(DependencyAnnotation)); + $__export("Query", Query); + Object.defineProperty(Query, "annotations", {get: function() { + return [new CONST()]; }}); } }; }); -System.register("angular2/src/render/dom/compiler/selector", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { +System.register("angular2/src/render/api", ["angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/collection", "angular2/change_detection"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/selector"; - var assert, + var __moduleName = "angular2/src/render/api"; + var isPresent, + Promise, List, Map, - ListWrapper, - MapWrapper, - isPresent, - isBlank, - RegExpWrapper, - RegExpMatcherWrapper, - StringWrapper, - BaseException, - _EMPTY_ATTR_VALUE, - _SELECTOR_REGEXP, - CssSelector, - SelectorMatcher, - SelectorListContext, - SelectorContext; + ASTWithSource, + EventBinding, + ElementBinder, + DirectiveBinder, + ProtoViewDto, + DirectiveMetadata, + RenderProtoViewRef, + RenderViewRef, + ViewDefinition, + RenderCompiler, + Renderer, + EventDispatcher; return { setters: [function($__m) { - assert = $__m.assert; + isPresent = $__m.isPresent; + }, function($__m) { + Promise = $__m.Promise; }, function($__m) { List = $__m.List; Map = $__m.Map; - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - RegExpWrapper = $__m.RegExpWrapper; - RegExpMatcherWrapper = $__m.RegExpMatcherWrapper; - StringWrapper = $__m.StringWrapper; - BaseException = $__m.BaseException; + ASTWithSource = $__m.ASTWithSource; }], execute: function() { - _EMPTY_ATTR_VALUE = ''; - _SELECTOR_REGEXP = RegExpWrapper.create('(\\:not\\()|' + '([-\\w]+)|' + '(?:\\.([-\\w]+))|' + '(?:\\[([-\\w*]+)(?:=([^\\]]*))?\\])|' + '(?:\\))|' + '(\\s*,\\s*)'); - CssSelector = (function() { - function CssSelector() { - this.element = null; - this.classNames = ListWrapper.create(); - this.attrs = ListWrapper.create(); - this.notSelector = null; + EventBinding = (function() { + function EventBinding(fullName, source) { + this.fullName = fullName; + this.source = source; } - return ($traceurRuntime.createClass)(CssSelector, { - isElementSelector: function() { - return assert.returnType((isPresent(this.element) && ListWrapper.isEmpty(this.classNames) && ListWrapper.isEmpty(this.attrs) && isBlank(this.notSelector)), assert.type.boolean); - }, - setElement: function() { - var element = arguments[0] !== (void 0) ? arguments[0] : null; - assert.argumentTypes(element, assert.type.string); - if (isPresent(element)) { - element = element.toLowerCase(); - } - this.element = element; - }, - addAttribute: function(name) { - var value = arguments[1] !== (void 0) ? arguments[1] : _EMPTY_ATTR_VALUE; - assert.argumentTypes(name, assert.type.string, value, assert.type.string); - ListWrapper.push(this.attrs, name.toLowerCase()); - if (isPresent(value)) { - value = value.toLowerCase(); - } else { - value = _EMPTY_ATTR_VALUE; - } - ListWrapper.push(this.attrs, value); - }, - addClassName: function(name) { - assert.argumentTypes(name, assert.type.string); - ListWrapper.push(this.classNames, name.toLowerCase()); - }, - toString: function() { - var res = ''; - if (isPresent(this.element)) { - res += this.element; - } - if (isPresent(this.classNames)) { - for (var i = 0; i < this.classNames.length; i++) { - res += '.' + this.classNames[i]; - } - } - if (isPresent(this.attrs)) { - for (var i = 0; i < this.attrs.length; ) { - var attrName = this.attrs[i++]; - var attrValue = this.attrs[i++]; - res += '[' + attrName; - if (attrValue.length > 0) { - res += '=' + attrValue; - } - res += ']'; - } - } - if (isPresent(this.notSelector)) { - res += ":not(" + this.notSelector.toString() + ")"; - } - return assert.returnType((res), assert.type.string); - } - }, {parse: function(selector) { - assert.argumentTypes(selector, assert.type.string); - var results = ListWrapper.create(); - var _addResult = (function(res, cssSel) { - if (isPresent(cssSel.notSelector) && isBlank(cssSel.element) && ListWrapper.isEmpty(cssSel.classNames) && ListWrapper.isEmpty(cssSel.attrs)) { - cssSel.element = "*"; - } - ListWrapper.push(res, cssSel); - }); - var cssSelector = new CssSelector(); - var matcher = RegExpWrapper.matcher(_SELECTOR_REGEXP, selector); - var match; - var current = cssSelector; - while (isPresent(match = RegExpMatcherWrapper.next(matcher))) { - if (isPresent(match[1])) { - if (isPresent(cssSelector.notSelector)) { - throw new BaseException('Nesting :not is not allowed in a selector'); - } - current.notSelector = new CssSelector(); - current = current.notSelector; - } - if (isPresent(match[2])) { - current.setElement(match[2]); - } - if (isPresent(match[3])) { - current.addClassName(match[3]); - } - if (isPresent(match[4])) { - current.addAttribute(match[4], match[5]); - } - if (isPresent(match[6])) { - _addResult(results, cssSelector); - cssSelector = current = new CssSelector(); - } - } - _addResult(results, cssSelector); - return assert.returnType((results), assert.genericType(List, CssSelector)); - }}); + return ($traceurRuntime.createClass)(EventBinding, {}, {}); + }()); + $__export("EventBinding", EventBinding); + Object.defineProperty(EventBinding, "parameters", {get: function() { + return [[assert.type.string], [ASTWithSource]]; + }}); + ElementBinder = (function() { + function ElementBinder($__1) { + var $__2 = $__1, + index = $__2.index, + parentIndex = $__2.parentIndex, + distanceToParent = $__2.distanceToParent, + directives = $__2.directives, + nestedProtoView = $__2.nestedProtoView, + propertyBindings = $__2.propertyBindings, + variableBindings = $__2.variableBindings, + eventBindings = $__2.eventBindings, + textBindings = $__2.textBindings, + readAttributes = $__2.readAttributes; + this.index = index; + this.parentIndex = parentIndex; + this.distanceToParent = distanceToParent; + this.directives = directives; + this.nestedProtoView = nestedProtoView; + this.propertyBindings = propertyBindings; + this.variableBindings = variableBindings; + this.eventBindings = eventBindings; + this.textBindings = textBindings; + this.readAttributes = readAttributes; + } + return ($traceurRuntime.createClass)(ElementBinder, {}, {}); }()); - $__export("CssSelector", CssSelector); - Object.defineProperty(CssSelector.parse, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(CssSelector.prototype.setElement, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(CssSelector.prototype.addAttribute, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(CssSelector.prototype.addClassName, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - SelectorMatcher = (function() { - function SelectorMatcher() { - this._elementMap = MapWrapper.create(); - this._elementPartialMap = MapWrapper.create(); - this._classMap = MapWrapper.create(); - this._classPartialMap = MapWrapper.create(); - this._attrValueMap = MapWrapper.create(); - this._attrValuePartialMap = MapWrapper.create(); - this._listContexts = ListWrapper.create(); + $__export("ElementBinder", ElementBinder); + DirectiveBinder = (function() { + function DirectiveBinder($__1) { + var $__2 = $__1, + directiveIndex = $__2.directiveIndex, + propertyBindings = $__2.propertyBindings, + eventBindings = $__2.eventBindings, + hostPropertyBindings = $__2.hostPropertyBindings; + this.directiveIndex = directiveIndex; + this.propertyBindings = propertyBindings; + this.eventBindings = eventBindings; + this.hostPropertyBindings = hostPropertyBindings; } - return ($traceurRuntime.createClass)(SelectorMatcher, { - addSelectables: function(cssSelectors, callbackCtxt) { - assert.argumentTypes(cssSelectors, assert.genericType(List, CssSelector), callbackCtxt, assert.type.any); - var listContext = null; - if (cssSelectors.length > 1) { - listContext = new SelectorListContext(cssSelectors); - ListWrapper.push(this._listContexts, listContext); - } - for (var i = 0; i < cssSelectors.length; i++) { - this.addSelectable(cssSelectors[i], callbackCtxt, listContext); - } - }, - addSelectable: function(cssSelector, callbackCtxt, listContext) { - assert.argumentTypes(cssSelector, assert.type.any, callbackCtxt, assert.type.any, listContext, SelectorListContext); - var matcher = this; - var element = cssSelector.element; - var classNames = cssSelector.classNames; - var attrs = cssSelector.attrs; - var selectable = new SelectorContext(cssSelector, callbackCtxt, listContext); - if (isPresent(element)) { - var isTerminal = attrs.length === 0 && classNames.length === 0; - if (isTerminal) { - this._addTerminal(matcher._elementMap, element, selectable); - } else { - matcher = this._addPartial(matcher._elementPartialMap, element); - } - } - if (isPresent(classNames)) { - for (var index = 0; index < classNames.length; index++) { - var isTerminal = attrs.length === 0 && index === classNames.length - 1; - var className = classNames[index]; - if (isTerminal) { - this._addTerminal(matcher._classMap, className, selectable); - } else { - matcher = this._addPartial(matcher._classPartialMap, className); - } - } - } - if (isPresent(attrs)) { - for (var index = 0; index < attrs.length; ) { - var isTerminal = index === attrs.length - 2; - var attrName = attrs[index++]; - var attrValue = attrs[index++]; - var map = isTerminal ? matcher._attrValueMap : matcher._attrValuePartialMap; - var valuesMap = MapWrapper.get(map, attrName); - if (isBlank(valuesMap)) { - valuesMap = MapWrapper.create(); - MapWrapper.set(map, attrName, valuesMap); - } - if (isTerminal) { - this._addTerminal(valuesMap, attrValue, selectable); - } else { - matcher = this._addPartial(valuesMap, attrValue); - } - } - } - }, - _addTerminal: function(map, name, selectable) { - assert.argumentTypes(map, assert.genericType(Map, assert.type.string, assert.type.string), name, assert.type.string, selectable, assert.type.any); - var terminalList = MapWrapper.get(map, name); - if (isBlank(terminalList)) { - terminalList = ListWrapper.create(); - MapWrapper.set(map, name, terminalList); - } - ListWrapper.push(terminalList, selectable); + return ($traceurRuntime.createClass)(DirectiveBinder, {}, {}); + }()); + $__export("DirectiveBinder", DirectiveBinder); + ProtoViewDto = (function() { + function ProtoViewDto() { + var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, + render = $__1.render, + elementBinders = $__1.elementBinders, + variableBindings = $__1.variableBindings, + type = $__1.type; + this.render = render; + this.elementBinders = elementBinders; + this.variableBindings = variableBindings; + this.type = type; + } + return ($traceurRuntime.createClass)(ProtoViewDto, {}, { + get HOST_VIEW_TYPE() { + return 0; }, - _addPartial: function(map, name) { - assert.argumentTypes(map, assert.genericType(Map, assert.type.string, assert.type.string), name, assert.type.string); - var matcher = MapWrapper.get(map, name); - if (isBlank(matcher)) { - matcher = new SelectorMatcher(); - MapWrapper.set(map, name, matcher); - } - return matcher; + get COMPONENT_VIEW_TYPE() { + return 1; }, - match: function(cssSelector, matchedCallback) { - assert.argumentTypes(cssSelector, CssSelector, matchedCallback, Function); - var result = false; - var element = cssSelector.element; - var classNames = cssSelector.classNames; - var attrs = cssSelector.attrs; - for (var i = 0; i < this._listContexts.length; i++) { - this._listContexts[i].alreadyMatched = false; - } - result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result; - result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) || result; - if (isPresent(classNames)) { - for (var index = 0; index < classNames.length; index++) { - var className = classNames[index]; - result = this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result; - result = this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) || result; - } - } - if (isPresent(attrs)) { - for (var index = 0; index < attrs.length; ) { - var attrName = attrs[index++]; - var attrValue = attrs[index++]; - var valuesMap = MapWrapper.get(this._attrValueMap, attrName); - if (!StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) { - result = this._matchTerminal(valuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) || result; - } - result = this._matchTerminal(valuesMap, attrValue, cssSelector, matchedCallback) || result; - valuesMap = MapWrapper.get(this._attrValuePartialMap, attrName); - result = this._matchPartial(valuesMap, attrValue, cssSelector, matchedCallback) || result; - } - } - return assert.returnType((result), assert.type.boolean); + get EMBEDDED_VIEW_TYPE() { + return 1; + } + }); + }()); + $__export("ProtoViewDto", ProtoViewDto); + DirectiveMetadata = (function() { + function DirectiveMetadata($__1) { + var $__2 = $__1, + id = $__2.id, + selector = $__2.selector, + compileChildren = $__2.compileChildren, + hostListeners = $__2.hostListeners, + hostProperties = $__2.hostProperties, + hostAttributes = $__2.hostAttributes, + hostActions = $__2.hostActions, + properties = $__2.properties, + readAttributes = $__2.readAttributes, + type = $__2.type; + this.id = id; + this.selector = selector; + this.compileChildren = isPresent(compileChildren) ? compileChildren : true; + this.hostListeners = hostListeners; + this.hostProperties = hostProperties; + this.hostAttributes = hostAttributes; + this.hostActions = hostActions; + this.properties = properties; + this.readAttributes = readAttributes; + this.type = type; + } + return ($traceurRuntime.createClass)(DirectiveMetadata, {}, { + get DIRECTIVE_TYPE() { + return 0; }, - _matchTerminal: function() { - var map = arguments[0] !== (void 0) ? arguments[0] : null; - var name = arguments[1]; - var cssSelector = arguments[2]; - var matchedCallback = arguments[3]; - assert.argumentTypes(map, assert.genericType(Map, assert.type.string, assert.type.string), name, assert.type.any, cssSelector, assert.type.any, matchedCallback, assert.type.any); - if (isBlank(map) || isBlank(name)) { - return assert.returnType((false), assert.type.boolean); - } - var selectables = MapWrapper.get(map, name); - var starSelectables = MapWrapper.get(map, "*"); - if (isPresent(starSelectables)) { - selectables = ListWrapper.concat(selectables, starSelectables); - } - if (isBlank(selectables)) { - return assert.returnType((false), assert.type.boolean); - } - var selectable; - var result = false; - for (var index = 0; index < selectables.length; index++) { - selectable = selectables[index]; - result = selectable.finalize(cssSelector, matchedCallback) || result; - } - return assert.returnType((result), assert.type.boolean); + get COMPONENT_TYPE() { + return 1; + } + }); + }()); + $__export("DirectiveMetadata", DirectiveMetadata); + RenderProtoViewRef = (function() { + function RenderProtoViewRef() {} + return ($traceurRuntime.createClass)(RenderProtoViewRef, {}, {}); + }()); + $__export("RenderProtoViewRef", RenderProtoViewRef); + RenderViewRef = (function() { + function RenderViewRef() {} + return ($traceurRuntime.createClass)(RenderViewRef, {}, {}); + }()); + $__export("RenderViewRef", RenderViewRef); + ViewDefinition = (function() { + function ViewDefinition($__1) { + var $__2 = $__1, + componentId = $__2.componentId, + absUrl = $__2.absUrl, + template = $__2.template, + directives = $__2.directives; + this.componentId = componentId; + this.absUrl = absUrl; + this.template = template; + this.directives = directives; + } + return ($traceurRuntime.createClass)(ViewDefinition, {}, {}); + }()); + $__export("ViewDefinition", ViewDefinition); + RenderCompiler = (function() { + function RenderCompiler() {} + return ($traceurRuntime.createClass)(RenderCompiler, { + compileHost: function(componentId) { + return null; }, - _matchPartial: function() { - var map = arguments[0] !== (void 0) ? arguments[0] : null; - var name = arguments[1]; - var cssSelector = arguments[2]; - var matchedCallback = arguments[3]; - assert.argumentTypes(map, assert.genericType(Map, assert.type.string, assert.type.string), name, assert.type.any, cssSelector, assert.type.any, matchedCallback, assert.type.any); - if (isBlank(map) || isBlank(name)) { - return assert.returnType((false), assert.type.boolean); - } - var nestedSelector = MapWrapper.get(map, name); - if (isBlank(nestedSelector)) { - return assert.returnType((false), assert.type.boolean); - } - return assert.returnType((nestedSelector.match(cssSelector, matchedCallback)), assert.type.boolean); + compile: function(template) { + return null; } }, {}); }()); - $__export("SelectorMatcher", SelectorMatcher); - Object.defineProperty(SelectorMatcher.prototype.addSelectables, "parameters", {get: function() { - return [[assert.genericType(List, CssSelector)], []]; + $__export("RenderCompiler", RenderCompiler); + Object.defineProperty(RenderCompiler.prototype.compile, "parameters", {get: function() { + return [[ViewDefinition]]; + }}); + Renderer = (function() { + function Renderer() {} + return ($traceurRuntime.createClass)(Renderer, { + createInPlaceHostView: function(parentHostViewRef, hostElementSelector, hostProtoViewRef) { + return null; + }, + destroyInPlaceHostView: function(parentHostViewRef, hostViewRef) {}, + createView: function(protoViewRef) { + return null; + }, + destroyView: function(viewRef) {}, + attachComponentView: function(hostViewRef, elementIndex, componentViewRef) {}, + detachComponentView: function(hostViewRef, boundElementIndex, componentViewRef) {}, + attachViewInContainer: function(parentViewRef, boundElementIndex, atIndex, viewRef) {}, + detachViewInContainer: function(parentViewRef, boundElementIndex, atIndex, viewRef) {}, + hydrateView: function(viewRef) {}, + dehydrateView: function(viewRef) {}, + setElementProperty: function(viewRef, elementIndex, propertyName, propertyValue) {}, + callAction: function(viewRef, elementIndex, actionExpression, actionArgs) {}, + setText: function(viewRef, textNodeIndex, text) {}, + setEventDispatcher: function(viewRef, dispatcher) {} + }, {}); + }()); + $__export("Renderer", Renderer); + Object.defineProperty(Renderer.prototype.createInPlaceHostView, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.string], [RenderProtoViewRef]]; }}); - Object.defineProperty(SelectorMatcher.prototype.addSelectable, "parameters", {get: function() { - return [[], [], [SelectorListContext]]; + Object.defineProperty(Renderer.prototype.destroyInPlaceHostView, "parameters", {get: function() { + return [[RenderViewRef], [RenderViewRef]]; }}); - Object.defineProperty(SelectorMatcher.prototype._addTerminal, "parameters", {get: function() { - return [[assert.genericType(Map, assert.type.string, assert.type.string)], [assert.type.string], []]; + Object.defineProperty(Renderer.prototype.createView, "parameters", {get: function() { + return [[RenderProtoViewRef]]; }}); - Object.defineProperty(SelectorMatcher.prototype._addPartial, "parameters", {get: function() { - return [[assert.genericType(Map, assert.type.string, assert.type.string)], [assert.type.string]]; + Object.defineProperty(Renderer.prototype.destroyView, "parameters", {get: function() { + return [[RenderViewRef]]; }}); - Object.defineProperty(SelectorMatcher.prototype.match, "parameters", {get: function() { - return [[CssSelector], [Function]]; + Object.defineProperty(Renderer.prototype.attachComponentView, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [RenderViewRef]]; }}); - Object.defineProperty(SelectorMatcher.prototype._matchTerminal, "parameters", {get: function() { - return [[assert.genericType(Map, assert.type.string, assert.type.string)], [], [], []]; + Object.defineProperty(Renderer.prototype.detachComponentView, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [RenderViewRef]]; }}); - Object.defineProperty(SelectorMatcher.prototype._matchPartial, "parameters", {get: function() { - return [[assert.genericType(Map, assert.type.string, assert.type.string)], [], [], []]; + Object.defineProperty(Renderer.prototype.attachViewInContainer, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.number], [RenderViewRef]]; }}); - SelectorListContext = (function() { - function SelectorListContext(selectors) { - assert.argumentTypes(selectors, assert.genericType(List, CssSelector)); - this.selectors = selectors; - this.alreadyMatched = false; - } - return ($traceurRuntime.createClass)(SelectorListContext, {}, {}); + Object.defineProperty(Renderer.prototype.detachViewInContainer, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.number], [RenderViewRef]]; + }}); + Object.defineProperty(Renderer.prototype.hydrateView, "parameters", {get: function() { + return [[RenderViewRef]]; + }}); + Object.defineProperty(Renderer.prototype.dehydrateView, "parameters", {get: function() { + return [[RenderViewRef]]; + }}); + Object.defineProperty(Renderer.prototype.setElementProperty, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.string], [assert.type.any]]; + }}); + Object.defineProperty(Renderer.prototype.callAction, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.string], [assert.type.any]]; + }}); + Object.defineProperty(Renderer.prototype.setText, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.string]]; + }}); + Object.defineProperty(Renderer.prototype.setEventDispatcher, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.any]]; + }}); + EventDispatcher = (function() { + function EventDispatcher() {} + return ($traceurRuntime.createClass)(EventDispatcher, {dispatchEvent: function(elementIndex, eventName, locals) {}}, {}); }()); - Object.defineProperty(SelectorListContext, "parameters", {get: function() { - return [[assert.genericType(List, CssSelector)]]; + $__export("EventDispatcher", EventDispatcher); + Object.defineProperty(EventDispatcher.prototype.dispatchEvent, "parameters", {get: function() { + return [[assert.type.number], [assert.type.string], [assert.genericType(Map, assert.type.string, assert.type.any)]]; }}); - SelectorContext = (function() { - function SelectorContext(selector, cbContext, listContext) { - assert.argumentTypes(selector, CssSelector, cbContext, assert.type.any, listContext, SelectorListContext); - this.selector = selector; - this.notSelector = selector.notSelector; - this.cbContext = cbContext; - this.listContext = listContext; + } + }; +}); + +System.register("angular2/src/render/dom/view/view_container", ["angular2/src/facade/collection", "angular2/src/render/dom/view/view"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/view/view_container"; + var ListWrapper, + MapWrapper, + List, + viewModule, + DomViewContainer; + return { + setters: [function($__m) { + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + List = $__m.List; + }, function($__m) { + viewModule = $__m; + }], + execute: function() { + DomViewContainer = (function() { + function DomViewContainer() { + this.views = []; } - return ($traceurRuntime.createClass)(SelectorContext, {finalize: function(cssSelector, callback) { - assert.argumentTypes(cssSelector, CssSelector, callback, assert.type.any); - var result = true; - if (isPresent(this.notSelector) && (isBlank(this.listContext) || !this.listContext.alreadyMatched)) { - var notMatcher = new SelectorMatcher(); - notMatcher.addSelectable(this.notSelector, null, null); - result = !notMatcher.match(cssSelector, null); - } - if (result && isPresent(callback) && (isBlank(this.listContext) || !this.listContext.alreadyMatched)) { - if (isPresent(this.listContext)) { - this.listContext.alreadyMatched = true; - } - callback(this.selector, this.cbContext); + return ($traceurRuntime.createClass)(DomViewContainer, { + contentTagContainers: function() { + return this.views; + }, + nodes: function() { + var r = []; + for (var i = 0; i < this.views.length; ++i) { + r = ListWrapper.concat(r, this.views[i].rootNodes); } - return result; - }}, {}); + return r; + } + }, {}); }()); - Object.defineProperty(SelectorContext, "parameters", {get: function() { - return [[CssSelector], [], [SelectorListContext]]; - }}); - Object.defineProperty(SelectorContext.prototype.finalize, "parameters", {get: function() { - return [[CssSelector], []]; - }}); + $__export("DomViewContainer", DomViewContainer); } }; }); -System.register("angular2/src/render/dom/compiler/view_splitter", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/change_detection", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/dom/util"], function($__export) { +System.register("angular2/src/render/dom/view/element_binder", ["angular2/change_detection", "angular2/src/reflection/types", "angular2/src/facade/collection", "angular2/src/render/dom/view/proto_view"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/view_splitter"; - var assert, - isBlank, - isPresent, - BaseException, - StringWrapper, - DOM, - MapWrapper, + var __moduleName = "angular2/src/render/dom/view/element_binder"; + var AST, + SetterFn, + List, ListWrapper, - Parser, - CompileStep, - CompileElement, - CompileControl, - dashCaseToCamelCase, - ViewSplitter; + protoViewModule, + ElementBinder, + Event, + HostAction; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - BaseException = $__m.BaseException; - StringWrapper = $__m.StringWrapper; + AST = $__m.AST; }, function($__m) { - DOM = $__m.DOM; + SetterFn = $__m.SetterFn; }, function($__m) { - MapWrapper = $__m.MapWrapper; + List = $__m.List; ListWrapper = $__m.ListWrapper; }, function($__m) { - Parser = $__m.Parser; - }, function($__m) { - CompileStep = $__m.CompileStep; - }, function($__m) { - CompileElement = $__m.CompileElement; - }, function($__m) { - CompileControl = $__m.CompileControl; - }, function($__m) { - dashCaseToCamelCase = $__m.dashCaseToCamelCase; + protoViewModule = $__m; }], execute: function() { - ViewSplitter = (function($__super) { - function ViewSplitter(parser) { - assert.argumentTypes(parser, Parser); - $traceurRuntime.superConstructor(ViewSplitter).call(this); - this._parser = parser; + ElementBinder = (function() { + function ElementBinder() { + var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, + textNodeIndices = $__1.textNodeIndices, + contentTagSelector = $__1.contentTagSelector, + nestedProtoView = $__1.nestedProtoView, + componentId = $__1.componentId, + eventLocals = $__1.eventLocals, + localEvents = $__1.localEvents, + globalEvents = $__1.globalEvents, + hostActions = $__1.hostActions, + parentIndex = $__1.parentIndex, + distanceToParent = $__1.distanceToParent, + propertySetters = $__1.propertySetters; + this.textNodeIndices = textNodeIndices; + this.contentTagSelector = contentTagSelector; + this.nestedProtoView = nestedProtoView; + this.componentId = componentId; + this.eventLocals = eventLocals; + this.localEvents = localEvents; + this.globalEvents = globalEvents; + this.hostActions = hostActions; + this.parentIndex = parentIndex; + this.distanceToParent = distanceToParent; + this.propertySetters = propertySetters; } - return ($traceurRuntime.createClass)(ViewSplitter, { - process: function(parent, current, control) { - assert.argumentTypes(parent, CompileElement, current, CompileElement, control, CompileControl); - var attrs = current.attrs(); - var templateBindings = MapWrapper.get(attrs, 'template'); - var hasTemplateBinding = isPresent(templateBindings); - MapWrapper.forEach(attrs, (function(attrValue, attrName) { - if (StringWrapper.startsWith(attrName, '*')) { - var key = StringWrapper.substring(attrName, 1); - if (hasTemplateBinding) { - throw new BaseException("Only one template directive per element is allowed: " + (templateBindings + " and " + key + " cannot be used simultaneously ") + ("in " + current.elementDescription)); - } else { - templateBindings = (attrValue.length == 0) ? key : key + ' ' + attrValue; - hasTemplateBinding = true; - } - } - })); - if (isPresent(parent)) { - if (DOM.isTemplateElement(current.element)) { - if (!current.isViewRoot) { - var viewRoot = new CompileElement(DOM.createTemplate('')); - viewRoot.inheritedProtoView = current.bindElement().bindNestedProtoView(viewRoot.element); - viewRoot.elementDescription = current.elementDescription; - viewRoot.isViewRoot = true; - this._moveChildNodes(DOM.content(current.element), DOM.content(viewRoot.element)); - control.addChild(viewRoot); - } - } - if (hasTemplateBinding) { - var newParent = new CompileElement(DOM.createTemplate('')); - newParent.inheritedProtoView = current.inheritedProtoView; - newParent.inheritedElementBinder = current.inheritedElementBinder; - newParent.distanceToInheritedBinder = current.distanceToInheritedBinder; - newParent.elementDescription = current.elementDescription; - current.inheritedProtoView = newParent.bindElement().bindNestedProtoView(current.element); - current.inheritedElementBinder = null; - current.distanceToInheritedBinder = 0; - current.isViewRoot = true; - this._parseTemplateBindings(templateBindings, newParent); - this._addParentElement(current.element, newParent.element); - control.addParent(newParent); - DOM.remove(current.element); - } - } - }, - _moveChildNodes: function(source, target) { - var next = DOM.firstChild(source); - while (isPresent(next)) { - DOM.appendChild(target, next); - next = DOM.firstChild(source); - } - }, - _addParentElement: function(currentElement, newParentElement) { - DOM.insertBefore(currentElement, newParentElement); - DOM.appendChild(newParentElement, currentElement); - }, - _parseTemplateBindings: function(templateBindings, compileElement) { - assert.argumentTypes(templateBindings, assert.type.string, compileElement, CompileElement); - var bindings = this._parser.parseTemplateBindings(templateBindings, compileElement.elementDescription); - for (var i = 0; i < bindings.length; i++) { - var binding = bindings[i]; - if (binding.keyIsVar) { - compileElement.bindElement().bindVariable(dashCaseToCamelCase(binding.key), binding.name); - MapWrapper.set(compileElement.attrs(), binding.key, binding.name); - } else if (isPresent(binding.expression)) { - compileElement.bindElement().bindProperty(dashCaseToCamelCase(binding.key), binding.expression); - MapWrapper.set(compileElement.attrs(), binding.key, binding.expression.source); - } else { - DOM.setAttribute(compileElement.element, binding.key, ''); - } - } - } - }, {}, $__super); - }(CompileStep)); - $__export("ViewSplitter", ViewSplitter); - Object.defineProperty(ViewSplitter, "parameters", {get: function() { - return [[Parser]]; + return ($traceurRuntime.createClass)(ElementBinder, {}, {}); + }()); + $__export("ElementBinder", ElementBinder); + Event = (function() { + function Event(name, target, fullName) { + this.name = name; + this.target = target; + this.fullName = fullName; + } + return ($traceurRuntime.createClass)(Event, {}, {}); + }()); + $__export("Event", Event); + Object.defineProperty(Event, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.type.string]]; }}); - Object.defineProperty(ViewSplitter.prototype.process, "parameters", {get: function() { - return [[CompileElement], [CompileElement], [CompileControl]]; + HostAction = (function() { + function HostAction(actionName, actionExpression, expression) { + this.actionName = actionName; + this.actionExpression = actionExpression; + this.expression = expression; + } + return ($traceurRuntime.createClass)(HostAction, {}, {}); + }()); + $__export("HostAction", HostAction); + Object.defineProperty(HostAction, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [AST]]; }}); - Object.defineProperty(ViewSplitter.prototype._parseTemplateBindings, "parameters", {get: function() { - return [[assert.type.string], [CompileElement]]; + } + }; +}); + +System.register("angular2/src/render/dom/util", ["angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/util"; + var StringWrapper, + RegExpWrapper, + isPresent, + NG_BINDING_CLASS_SELECTOR, + NG_BINDING_CLASS, + EVENT_TARGET_SEPARATOR, + CAMEL_CASE_REGEXP, + DASH_CASE_REGEXP; + function camelCaseToDashCase(input) { + return StringWrapper.replaceAllMapped(input, CAMEL_CASE_REGEXP, (function(m) { + return '-' + m[1].toLowerCase(); + })); + } + function dashCaseToCamelCase(input) { + return StringWrapper.replaceAllMapped(input, DASH_CASE_REGEXP, (function(m) { + return m[1].toUpperCase(); + })); + } + $__export("camelCaseToDashCase", camelCaseToDashCase); + $__export("dashCaseToCamelCase", dashCaseToCamelCase); + return { + setters: [function($__m) { + StringWrapper = $__m.StringWrapper; + RegExpWrapper = $__m.RegExpWrapper; + isPresent = $__m.isPresent; + }], + execute: function() { + NG_BINDING_CLASS_SELECTOR = '.ng-binding'; + $__export("NG_BINDING_CLASS_SELECTOR", NG_BINDING_CLASS_SELECTOR); + NG_BINDING_CLASS = 'ng-binding'; + $__export("NG_BINDING_CLASS", NG_BINDING_CLASS); + EVENT_TARGET_SEPARATOR = ':'; + $__export("EVENT_TARGET_SEPARATOR", EVENT_TARGET_SEPARATOR); + CAMEL_CASE_REGEXP = RegExpWrapper.create('([A-Z])'); + DASH_CASE_REGEXP = RegExpWrapper.create('-([a-z])'); + Object.defineProperty(camelCaseToDashCase, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(dashCaseToCamelCase, "parameters", {get: function() { + return [[assert.type.string]]; }}); } }; }); -System.register("angular2/src/render/dom/shadow_dom/shadow_dom_compile_step", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/api", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/content_tag", ["angular2/src/render/dom/shadow_dom/light_dom", "angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/shadow_dom_compile_step"; - var assert, - isBlank, + var __moduleName = "angular2/src/render/dom/shadow_dom/content_tag"; + var ldModule, + DOM, isPresent, - assertionsEnabled, - MapWrapper, List, ListWrapper, - Promise, - PromiseWrapper, - DOM, - CompileStep, - CompileElement, - CompileControl, - ViewDefinition, - ShadowDomStrategy, - ShadowDomCompileStep; + ContentStrategy, + RenderedContent, + IntermediateContent, + Content; return { setters: [function($__m) { - assert = $__m.assert; + ldModule = $__m; + }, function($__m) { + DOM = $__m.DOM; }, function($__m) { - isBlank = $__m.isBlank; isPresent = $__m.isPresent; - assertionsEnabled = $__m.assertionsEnabled; }, function($__m) { - MapWrapper = $__m.MapWrapper; List = $__m.List; ListWrapper = $__m.ListWrapper; - }, function($__m) { - Promise = $__m.Promise; - PromiseWrapper = $__m.PromiseWrapper; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - CompileStep = $__m.CompileStep; - }, function($__m) { - CompileElement = $__m.CompileElement; - }, function($__m) { - CompileControl = $__m.CompileControl; - }, function($__m) { - ViewDefinition = $__m.ViewDefinition; - }, function($__m) { - ShadowDomStrategy = $__m.ShadowDomStrategy; }], execute: function() { - ShadowDomCompileStep = (function($__super) { - function ShadowDomCompileStep(shadowDomStrategy, template, subTaskPromises) { - assert.argumentTypes(shadowDomStrategy, ShadowDomStrategy, template, ViewDefinition, subTaskPromises, assert.genericType(List, Promise)); - $traceurRuntime.superConstructor(ShadowDomCompileStep).call(this); - this._shadowDomStrategy = shadowDomStrategy; - this._template = template; - this._subTaskPromises = subTaskPromises; + ContentStrategy = (function() { + function ContentStrategy() {} + return ($traceurRuntime.createClass)(ContentStrategy, {insert: function(nodes) {}}, {}); + }()); + Object.defineProperty(ContentStrategy.prototype.insert, "parameters", {get: function() { + return [[List]]; + }}); + RenderedContent = (function($__super) { + function RenderedContent(contentEl) { + $traceurRuntime.superConstructor(RenderedContent).call(this); + this.beginScript = contentEl; + this.endScript = DOM.nextSibling(this.beginScript); + this.nodes = []; } - return ($traceurRuntime.createClass)(ShadowDomCompileStep, { - process: function(parent, current, control) { - assert.argumentTypes(parent, CompileElement, current, CompileElement, control, CompileControl); - var tagName = DOM.tagName(current.element).toUpperCase(); - if (tagName == 'STYLE') { - this._processStyleElement(current, control); - } else if (tagName == 'CONTENT') { - this._processContentElement(current); - } else { - var componentId = current.isBound() ? current.inheritedElementBinder.componentId : null; - this._shadowDomStrategy.processElement(this._template.componentId, componentId, current.element); - } - }, - _processStyleElement: function(current, control) { - assert.argumentTypes(current, CompileElement, control, CompileControl); - var stylePromise = this._shadowDomStrategy.processStyleElement(this._template.componentId, this._template.absUrl, current.element); - if (isPresent(stylePromise) && PromiseWrapper.isPromise(stylePromise)) { - ListWrapper.push(this._subTaskPromises, stylePromise); - } - control.ignoreCurrentElement(); + return ($traceurRuntime.createClass)(RenderedContent, { + insert: function(nodes) { + this.nodes = nodes; + DOM.insertAllBefore(this.endScript, nodes); + this._removeNodesUntil(ListWrapper.isEmpty(nodes) ? this.endScript : nodes[0]); }, - _processContentElement: function(current) { - assert.argumentTypes(current, CompileElement); - if (this._shadowDomStrategy.hasNativeContentElement()) { - return ; - } - var attrs = current.attrs(); - var selector = MapWrapper.get(attrs, 'select'); - selector = isPresent(selector) ? selector : ''; - var contentStart = DOM.createScriptTag('type', 'ng/contentStart'); - if (assertionsEnabled()) { - DOM.setAttribute(contentStart, 'select', selector); + _removeNodesUntil: function(node) { + var p = DOM.parentElement(this.beginScript); + for (var next = DOM.nextSibling(this.beginScript); next !== node; next = DOM.nextSibling(this.beginScript)) { + DOM.removeChild(p, next); } - var contentEnd = DOM.createScriptTag('type', 'ng/contentEnd'); - DOM.insertBefore(current.element, contentStart); - DOM.insertBefore(current.element, contentEnd); - DOM.remove(current.element); - current.element = contentStart; - current.bindElement().setContentTagSelector(selector); } }, {}, $__super); - }(CompileStep)); - $__export("ShadowDomCompileStep", ShadowDomCompileStep); - Object.defineProperty(ShadowDomCompileStep, "parameters", {get: function() { - return [[ShadowDomStrategy], [ViewDefinition], [assert.genericType(List, Promise)]]; + }(ContentStrategy)); + Object.defineProperty(RenderedContent.prototype.insert, "parameters", {get: function() { + return [[List]]; }}); - Object.defineProperty(ShadowDomCompileStep.prototype.process, "parameters", {get: function() { - return [[CompileElement], [CompileElement], [CompileControl]]; + IntermediateContent = (function($__super) { + function IntermediateContent(destinationLightDom) { + $traceurRuntime.superConstructor(IntermediateContent).call(this); + this.nodes = []; + this.destinationLightDom = destinationLightDom; + } + return ($traceurRuntime.createClass)(IntermediateContent, {insert: function(nodes) { + this.nodes = nodes; + this.destinationLightDom.redistribute(); + }}, {}, $__super); + }(ContentStrategy)); + Object.defineProperty(IntermediateContent, "parameters", {get: function() { + return [[ldModule.LightDom]]; }}); - Object.defineProperty(ShadowDomCompileStep.prototype._processStyleElement, "parameters", {get: function() { - return [[CompileElement], [CompileControl]]; + Object.defineProperty(IntermediateContent.prototype.insert, "parameters", {get: function() { + return [[List]]; }}); - Object.defineProperty(ShadowDomCompileStep.prototype._processContentElement, "parameters", {get: function() { - return [[CompileElement]]; + Content = (function() { + function Content(contentStartEl, selector) { + this.select = selector; + this.contentStartElement = contentStartEl; + this._strategy = null; + } + return ($traceurRuntime.createClass)(Content, { + init: function(destinationLightDom) { + this._strategy = isPresent(destinationLightDom) ? new IntermediateContent(destinationLightDom) : new RenderedContent(this.contentStartElement); + }, + nodes: function() { + return this._strategy.nodes; + }, + insert: function(nodes) { + this._strategy.insert(nodes); + } + }, {}); + }()); + $__export("Content", Content); + Object.defineProperty(Content, "parameters", {get: function() { + return [[], [assert.type.string]]; + }}); + Object.defineProperty(Content.prototype.init, "parameters", {get: function() { + return [[ldModule.LightDom]]; + }}); + Object.defineProperty(Content.prototype.insert, "parameters", {get: function() { + return [[List]]; }}); } }; }); -System.register("angular2/src/core/compiler/view_container_ref", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/di", "angular2/src/facade/lang", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/element_ref", "angular2/src/core/compiler/view_ref"], function($__export) { +System.register("angular2/src/core/compiler/view_container_ref", ["angular2/src/facade/collection", "angular2/di", "angular2/src/facade/lang", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/element_ref", "angular2/src/core/compiler/view_ref"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/view_container_ref"; - var assert, - ListWrapper, + var ListWrapper, List, Injector, isPresent, @@ -16753,8 +11326,6 @@ System.register("angular2/src/core/compiler/view_container_ref", ["rtts_assert/r ViewContainerRef; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { ListWrapper = $__m.ListWrapper; List = $__m.List; }, function($__m) { @@ -16774,7 +11345,6 @@ System.register("angular2/src/core/compiler/view_container_ref", ["rtts_assert/r execute: function() { ViewContainerRef = (function() { function ViewContainerRef(viewManager, element) { - assert.argumentTypes(viewManager, avmModule.AppViewManager, element, ElementRef); this._viewManager = viewManager; this._element = element; } @@ -16789,8 +11359,7 @@ System.register("angular2/src/core/compiler/view_container_ref", ["rtts_assert/r } }, get: function(index) { - assert.argumentTypes(index, assert.type.number); - return assert.returnType((new ViewRef(this._getViews()[index])), ViewRef); + return new ViewRef(this._getViews()[index]); }, get length() { return this._getViews().length; @@ -16798,36 +11367,32 @@ System.register("angular2/src/core/compiler/view_container_ref", ["rtts_assert/r create: function() { var protoViewRef = arguments[0] !== (void 0) ? arguments[0] : null; var atIndex = arguments[1] !== (void 0) ? arguments[1] : -1; - var injector = arguments[2] !== (void 0) ? arguments[2] : null; - assert.argumentTypes(protoViewRef, ProtoViewRef, atIndex, assert.type.number, injector, Injector); + var context = arguments[2]; + var injector = arguments[3] !== (void 0) ? arguments[3] : null; if (atIndex == -1) atIndex = this.length; - return assert.returnType((this._viewManager.createViewInContainer(this._element, atIndex, protoViewRef, injector)), ViewRef); + return this._viewManager.createViewInContainer(this._element, atIndex, protoViewRef, context, injector); }, insert: function(viewRef) { var atIndex = arguments[1] !== (void 0) ? arguments[1] : -1; - assert.argumentTypes(viewRef, ViewRef, atIndex, assert.type.number); if (atIndex == -1) atIndex = this.length; - return assert.returnType((this._viewManager.attachViewInContainer(this._element, atIndex, viewRef)), ViewRef); + return this._viewManager.attachViewInContainer(this._element, atIndex, viewRef); }, indexOf: function(viewRef) { - assert.argumentTypes(viewRef, ViewRef); return ListWrapper.indexOf(this._getViews(), internalView(viewRef)); }, remove: function() { var atIndex = arguments[0] !== (void 0) ? arguments[0] : -1; - assert.argumentTypes(atIndex, assert.type.number); if (atIndex == -1) atIndex = this.length - 1; this._viewManager.destroyViewInContainer(this._element, atIndex); }, detach: function() { var atIndex = arguments[0] !== (void 0) ? arguments[0] : -1; - assert.argumentTypes(atIndex, assert.type.number); if (atIndex == -1) atIndex = this.length - 1; - return assert.returnType((this._viewManager.detachViewInContainer(this._element, atIndex)), ViewRef); + return this._viewManager.detachViewInContainer(this._element, atIndex); } }, {}); }()); @@ -16839,7 +11404,7 @@ System.register("angular2/src/core/compiler/view_container_ref", ["rtts_assert/r return [[assert.type.number]]; }}); Object.defineProperty(ViewContainerRef.prototype.create, "parameters", {get: function() { - return [[ProtoViewRef], [assert.type.number], [Injector]]; + return [[ProtoViewRef], [assert.type.number], [ElementRef], [Injector]]; }}); Object.defineProperty(ViewContainerRef.prototype.insert, "parameters", {get: function() { return [[ViewRef], [assert.type.number]]; @@ -16857,13 +11422,12 @@ System.register("angular2/src/core/compiler/view_container_ref", ["rtts_assert/r }; }); -System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/collection", "angular2/src/core/compiler/element_injector", "angular2/src/facade/lang", "angular2/src/core/compiler/view", "angular2/src/core/compiler/view_manager", "angular2/src/render/api", "angular2/change_detection", "angular2/src/core/compiler/directive_metadata_reader"], function($__export) { +System.register("angular2/src/core/compiler/view_manager_utils", ["angular2/di", "angular2/src/di/annotations_impl", "angular2/src/facade/collection", "angular2/src/core/compiler/element_injector", "angular2/src/facade/lang", "angular2/src/core/compiler/view", "angular2/src/core/compiler/view_manager", "angular2/src/render/api", "angular2/change_detection", "angular2/src/core/compiler/directive_metadata_reader"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/view_manager_utils"; - var assert, - Injectable, - Injector, + var Injector, Binding, + Injectable, ListWrapper, MapWrapper, Map, @@ -16879,14 +11443,14 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r BindingPropagationConfig, Locals, DirectiveMetadataReader, + RenderViewRef, AppViewManagerUtils; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; Injector = $__m.Injector; Binding = $__m.Binding; + }, function($__m) { + Injectable = $__m.Injectable; }, function($__m) { ListWrapper = $__m.ListWrapper; MapWrapper = $__m.MapWrapper; @@ -16905,6 +11469,7 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r avmModule = $__m; }, function($__m) { Renderer = $__m.Renderer; + RenderViewRef = $__m.RenderViewRef; }, function($__m) { BindingPropagationConfig = $__m.BindingPropagationConfig; Locals = $__m.Locals; @@ -16914,24 +11479,22 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r execute: function() { AppViewManagerUtils = (function() { function AppViewManagerUtils(metadataReader) { - assert.argumentTypes(metadataReader, DirectiveMetadataReader); this._metadataReader = metadataReader; } return ($traceurRuntime.createClass)(AppViewManagerUtils, { getComponentInstance: function(parentView, boundElementIndex) { - assert.argumentTypes(parentView, viewModule.AppView, boundElementIndex, assert.type.number); var binder = parentView.proto.elementBinders[boundElementIndex]; var eli = parentView.elementInjectors[boundElementIndex]; if (binder.hasDynamicComponent()) { - return assert.returnType((eli.getDynamicallyLoadedComponent()), assert.type.any); + return eli.getDynamicallyLoadedComponent(); } else { - return assert.returnType((eli.getComponent()), assert.type.any); + return eli.getComponent(); } }, - createView: function(protoView, viewManager, renderer) { - assert.argumentTypes(protoView, viewModule.AppProtoView, viewManager, avmModule.AppViewManager, renderer, Renderer); + createView: function(protoView, renderView, viewManager, renderer) { var view = new viewModule.AppView(renderer, protoView, protoView.protoLocals); - var changeDetector = protoView.protoChangeDetector.instantiate(view, protoView.bindings, protoView.getVariableBindings(), protoView.getdirectiveRecords()); + view.render = renderView; + var changeDetector = protoView.protoChangeDetector.instantiate(view); var binders = protoView.elementBinders; var elementInjectors = ListWrapper.createFixedSize(binders.length); var rootElementInjectors = []; @@ -16957,23 +11520,20 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r } } view.init(changeDetector, elementInjectors, rootElementInjectors, preBuiltObjects, componentChildViews); - return assert.returnType((view), viewModule.AppView); + return view; }, attachComponentView: function(hostView, boundElementIndex, componentView) { - assert.argumentTypes(hostView, viewModule.AppView, boundElementIndex, assert.type.number, componentView, viewModule.AppView); var childChangeDetector = componentView.changeDetector; hostView.changeDetector.addShadowDomChild(childChangeDetector); hostView.componentChildViews[boundElementIndex] = componentView; }, detachComponentView: function(hostView, boundElementIndex) { - assert.argumentTypes(hostView, viewModule.AppView, boundElementIndex, assert.type.number); var componentView = hostView.componentChildViews[boundElementIndex]; hostView.changeDetector.removeShadowDomChild(componentView.changeDetector); hostView.componentChildViews[boundElementIndex] = null; }, hydrateComponentView: function(hostView, boundElementIndex) { var injector = arguments[2] !== (void 0) ? arguments[2] : null; - assert.argumentTypes(hostView, viewModule.AppView, boundElementIndex, assert.type.number, injector, Injector); var elementInjector = hostView.elementInjectors[boundElementIndex]; var componentView = hostView.componentChildViews[boundElementIndex]; var component = this.getComponentInstance(hostView, boundElementIndex); @@ -16981,25 +11541,26 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r }, attachAndHydrateInPlaceHostView: function(parentComponentHostView, parentComponentBoundElementIndex, hostView) { var injector = arguments[3] !== (void 0) ? arguments[3] : null; - assert.argumentTypes(parentComponentHostView, viewModule.AppView, parentComponentBoundElementIndex, assert.type.number, hostView, viewModule.AppView, injector, Injector); var hostElementInjector = null; if (isPresent(parentComponentHostView)) { hostElementInjector = parentComponentHostView.elementInjectors[parentComponentBoundElementIndex]; var parentView = parentComponentHostView.componentChildViews[parentComponentBoundElementIndex]; parentView.changeDetector.addChild(hostView.changeDetector); - ListWrapper.push(parentView.imperativeHostViews, hostView); + ListWrapper.push(parentView.inPlaceHostViews, hostView); } this._hydrateView(hostView, injector, hostElementInjector, new Object(), null); }, detachInPlaceHostView: function(parentView, hostView) { - assert.argumentTypes(parentView, viewModule.AppView, hostView, viewModule.AppView); if (isPresent(parentView)) { parentView.changeDetector.removeChild(hostView.changeDetector); - ListWrapper.remove(parentView.imperativeHostViews, hostView); + ListWrapper.remove(parentView.inPlaceHostViews, hostView); } }, - attachViewInContainer: function(parentView, boundElementIndex, atIndex, view) { - assert.argumentTypes(parentView, viewModule.AppView, boundElementIndex, assert.type.number, atIndex, assert.type.number, view, viewModule.AppView); + attachViewInContainer: function(parentView, boundElementIndex, contextView, contextBoundElementIndex, atIndex, view) { + if (isBlank(contextView)) { + contextView = parentView; + contextBoundElementIndex = boundElementIndex; + } parentView.changeDetector.addChild(view.changeDetector); var viewContainer = parentView.viewContainers[boundElementIndex]; if (isBlank(viewContainer)) { @@ -17013,13 +11574,12 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r } else { sibling = ListWrapper.last(viewContainer.views[atIndex - 1].rootElementInjectors); } - var elementInjector = parentView.elementInjectors[boundElementIndex]; + var elementInjector = contextView.elementInjectors[contextBoundElementIndex]; for (var i = view.rootElementInjectors.length - 1; i >= 0; i--) { view.rootElementInjectors[i].linkAfter(elementInjector, sibling); } }, detachViewInContainer: function(parentView, boundElementIndex, atIndex) { - assert.argumentTypes(parentView, viewModule.AppView, boundElementIndex, assert.type.number, atIndex, assert.type.number); var viewContainer = parentView.viewContainers[boundElementIndex]; var view = viewContainer.views[atIndex]; view.changeDetector.remove(); @@ -17028,16 +11588,18 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r view.rootElementInjectors[i].unlink(); } }, - hydrateViewInContainer: function(parentView, boundElementIndex, atIndex, injector) { - assert.argumentTypes(parentView, viewModule.AppView, boundElementIndex, assert.type.number, atIndex, assert.type.number, injector, Injector); + hydrateViewInContainer: function(parentView, boundElementIndex, contextView, contextBoundElementIndex, atIndex, injector) { + if (isBlank(contextView)) { + contextView = parentView; + contextBoundElementIndex = boundElementIndex; + } var viewContainer = parentView.viewContainers[boundElementIndex]; var view = viewContainer.views[atIndex]; - var elementInjector = parentView.elementInjectors[boundElementIndex]; - this._hydrateView(view, injector, elementInjector, parentView.context, parentView.locals); + var elementInjector = contextView.elementInjectors[contextBoundElementIndex].getHost(); + this._hydrateView(view, injector, elementInjector, contextView.context, contextView.locals); }, hydrateDynamicComponentInElementInjector: function(hostView, boundElementIndex, componentBinding) { var injector = arguments[3] !== (void 0) ? arguments[3] : null; - assert.argumentTypes(hostView, viewModule.AppView, boundElementIndex, assert.type.number, componentBinding, Binding, injector, Injector); var elementInjector = hostView.elementInjectors[boundElementIndex]; if (isPresent(elementInjector.getDynamicallyLoadedComponent())) { throw new BaseException(("There already is a dynamic component loaded at element " + boundElementIndex)); @@ -17047,21 +11609,9 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r } var annotation = this._metadataReader.read(componentBinding.token).annotation; var componentDirective = eli.DirectiveBinding.createFromBinding(componentBinding, annotation); - var shadowDomAppInjector = this._createShadowDomAppInjector(componentDirective, injector); - elementInjector.dynamicallyCreateComponent(componentDirective, shadowDomAppInjector); - }, - _createShadowDomAppInjector: function(componentDirective, appInjector) { - var shadowDomAppInjector = null; - var injectables = componentDirective.resolvedInjectables; - if (isPresent(injectables)) { - shadowDomAppInjector = appInjector.createChildFromResolved(injectables); - } else { - shadowDomAppInjector = appInjector; - } - return shadowDomAppInjector; + elementInjector.dynamicallyCreateComponent(componentDirective, injector); }, _hydrateView: function(view, appInjector, hostElementInjector, context, parentLocals) { - assert.argumentTypes(view, viewModule.AppView, appInjector, Injector, hostElementInjector, eli.ElementInjector, context, Object, parentLocals, Locals); if (isBlank(appInjector)) { appInjector = hostElementInjector.getShadowDomAppInjector(); } @@ -17070,20 +11620,13 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r } view.context = context; view.locals.parent = parentLocals; - view.changeDetector.hydrate(view.context, view.locals, view); var binders = view.proto.elementBinders; for (var i = 0; i < binders.length; ++i) { var elementInjector = view.elementInjectors[i]; if (isPresent(elementInjector)) { - var componentDirective = view.proto.elementBinders[i].componentDirective; - var shadowDomAppInjector = null; - if (isPresent(componentDirective)) { - shadowDomAppInjector = this._createShadowDomAppInjector(componentDirective, appInjector); - } else { - shadowDomAppInjector = null; - } - elementInjector.instantiateDirectives(appInjector, hostElementInjector, shadowDomAppInjector, view.preBuiltObjects[i]); + elementInjector.instantiateDirectives(appInjector, hostElementInjector, view.preBuiltObjects[i]); this._setUpEventEmitters(view, elementInjector, i); + this._setUpHostActions(view, elementInjector, i); var exportImplicitName = elementInjector.getExportImplicitName(); if (elementInjector.isExportingComponent()) { view.locals.set(exportImplicitName, elementInjector.getComponent()); @@ -17092,9 +11635,9 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r } } } + view.changeDetector.hydrate(view.context, view.locals, view); }, _setUpEventEmitters: function(view, elementInjector, boundElementIndex) { - assert.argumentTypes(view, viewModule.AppView, elementInjector, eli.ElementInjector, boundElementIndex, assert.type.number); var emitters = elementInjector.getEventEmitterAccessors(); for (var directiveIndex = 0; directiveIndex < emitters.length; ++directiveIndex) { var directiveEmitters = emitters[directiveIndex]; @@ -17105,8 +11648,18 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r } } }, + _setUpHostActions: function(view, elementInjector, boundElementIndex) { + var hostActions = elementInjector.getHostActionAccessors(); + for (var directiveIndex = 0; directiveIndex < hostActions.length; ++directiveIndex) { + var directiveHostActions = hostActions[directiveIndex]; + var directive = elementInjector.getDirectiveAtIndex(directiveIndex); + for (var index = 0; index < directiveHostActions.length; ++index) { + var hostActionAccessor = directiveHostActions[index]; + hostActionAccessor.subscribe(view, boundElementIndex, directive); + } + } + }, dehydrateView: function(view) { - assert.argumentTypes(view, viewModule.AppView); var binders = view.proto.elementBinders; for (var i = 0; i < binders.length; ++i) { var elementInjector = view.elementInjectors[i]; @@ -17133,7 +11686,7 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r return [[viewModule.AppView], [assert.type.number]]; }}); Object.defineProperty(AppViewManagerUtils.prototype.createView, "parameters", {get: function() { - return [[viewModule.AppProtoView], [avmModule.AppViewManager], [Renderer]]; + return [[viewModule.AppProtoView], [RenderViewRef], [avmModule.AppViewManager], [Renderer]]; }}); Object.defineProperty(AppViewManagerUtils.prototype.attachComponentView, "parameters", {get: function() { return [[viewModule.AppView], [assert.type.number], [viewModule.AppView]]; @@ -17151,13 +11704,13 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r return [[viewModule.AppView], [viewModule.AppView]]; }}); Object.defineProperty(AppViewManagerUtils.prototype.attachViewInContainer, "parameters", {get: function() { - return [[viewModule.AppView], [assert.type.number], [assert.type.number], [viewModule.AppView]]; + return [[viewModule.AppView], [assert.type.number], [viewModule.AppView], [assert.type.number], [assert.type.number], [viewModule.AppView]]; }}); Object.defineProperty(AppViewManagerUtils.prototype.detachViewInContainer, "parameters", {get: function() { return [[viewModule.AppView], [assert.type.number], [assert.type.number]]; }}); Object.defineProperty(AppViewManagerUtils.prototype.hydrateViewInContainer, "parameters", {get: function() { - return [[viewModule.AppView], [assert.type.number], [assert.type.number], [Injector]]; + return [[viewModule.AppView], [assert.type.number], [viewModule.AppView], [assert.type.number], [assert.type.number], [Injector]]; }}); Object.defineProperty(AppViewManagerUtils.prototype.hydrateDynamicComponentInElementInjector, "parameters", {get: function() { return [[viewModule.AppView], [assert.type.number], [Binding], [Injector]]; @@ -17168,6 +11721,9 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r Object.defineProperty(AppViewManagerUtils.prototype._setUpEventEmitters, "parameters", {get: function() { return [[viewModule.AppView], [eli.ElementInjector], [assert.type.number]]; }}); + Object.defineProperty(AppViewManagerUtils.prototype._setUpHostActions, "parameters", {get: function() { + return [[viewModule.AppView], [eli.ElementInjector], [assert.type.number]]; + }}); Object.defineProperty(AppViewManagerUtils.prototype.dehydrateView, "parameters", {get: function() { return [[viewModule.AppView]]; }}); @@ -17175,12 +11731,10 @@ System.register("angular2/src/core/compiler/view_manager_utils", ["rtts_assert/r }; }); -System.register("angular2/src/core/compiler/view_pool", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/core/compiler/view"], function($__export) { +System.register("angular2/src/core/compiler/view_pool", ["angular2/src/di/annotations_impl", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/core/compiler/view"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/view_pool"; - var assert, - Inject, - OpaqueToken, + var Inject, ListWrapper, MapWrapper, Map, @@ -17192,10 +11746,7 @@ System.register("angular2/src/core/compiler/view_pool", ["rtts_assert/rtts_asser AppViewPool; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Inject = $__m.Inject; - OpaqueToken = $__m.OpaqueToken; }, function($__m) { ListWrapper = $__m.ListWrapper; MapWrapper = $__m.MapWrapper; @@ -17217,15 +11768,13 @@ System.register("angular2/src/core/compiler/view_pool", ["rtts_assert/rtts_asser } return ($traceurRuntime.createClass)(AppViewPool, { getView: function(protoView) { - assert.argumentTypes(protoView, viewModule.AppProtoView); var pooledViews = MapWrapper.get(this._pooledViewsPerProtoView, protoView); if (isPresent(pooledViews) && pooledViews.length > 0) { - return assert.returnType((ListWrapper.removeLast(pooledViews)), viewModule.AppView); + return ListWrapper.removeLast(pooledViews); } - return assert.returnType((null), viewModule.AppView); + return null; }, returnView: function(view) { - assert.argumentTypes(view, viewModule.AppView); var protoView = view.proto; var pooledViews = MapWrapper.get(this._pooledViewsPerProtoView, protoView); if (isBlank(pooledViews)) { @@ -17332,11 +11881,10 @@ System.register("angular2/src/core/compiler/base_query_list", ["angular2/src/fac }; }); -System.register("angular2/src/core/compiler/element_binder", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/core/compiler/element_injector", "angular2/src/facade/collection", "angular2/src/core/compiler/view"], function($__export) { +System.register("angular2/src/core/compiler/element_binder", ["angular2/src/facade/lang", "angular2/src/core/compiler/element_injector", "angular2/src/facade/collection", "angular2/src/core/compiler/view"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/element_binder"; - var assert, - int, + var int, isBlank, isPresent, BaseException, @@ -17348,8 +11896,6 @@ System.register("angular2/src/core/compiler/element_binder", ["rtts_assert/rtts_ ElementBinder; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { int = $__m.int; isBlank = $__m.isBlank; isPresent = $__m.isPresent; @@ -17366,7 +11912,6 @@ System.register("angular2/src/core/compiler/element_binder", ["rtts_assert/rtts_ execute: function() { ElementBinder = (function() { function ElementBinder(index, parent, distanceToParent, protoElementInjector, componentDirective) { - assert.argumentTypes(index, int, parent, ElementBinder, distanceToParent, int, protoElementInjector, eiModule.ProtoElementInjector, componentDirective, DirectiveBinding); if (isBlank(index)) { throw new BaseException('null index not allowed.'); } @@ -17398,11 +11943,10 @@ System.register("angular2/src/core/compiler/element_binder", ["rtts_assert/rtts_ }; }); -System.register("angular2/src/core/compiler/template_resolver", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/core/annotations_impl/view", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/reflection/reflection"], function($__export) { +System.register("angular2/src/core/compiler/template_resolver", ["angular2/src/di/annotations_impl", "angular2/src/core/annotations_impl/view", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/reflection/reflection"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/template_resolver"; - var assert, - Injectable, + var Injectable, View, Type, stringify, @@ -17416,8 +11960,6 @@ System.register("angular2/src/core/compiler/template_resolver", ["rtts_assert/rt TemplateResolver; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injectable = $__m.Injectable; }, function($__m) { View = $__m.View; @@ -17441,16 +11983,14 @@ System.register("angular2/src/core/compiler/template_resolver", ["rtts_assert/rt } return ($traceurRuntime.createClass)(TemplateResolver, { resolve: function(component) { - assert.argumentTypes(component, Type); var view = MapWrapper.get(this._cache, component); if (isBlank(view)) { view = this._resolve(component); MapWrapper.set(this._cache, component, view); } - return assert.returnType((view), View); + return view; }, _resolve: function(component) { - assert.argumentTypes(component, Type); var annotations = reflector.annotations(component); for (var i = 0; i < annotations.length; i++) { var annotation = annotations[i]; @@ -17476,11 +12016,10 @@ System.register("angular2/src/core/compiler/template_resolver", ["rtts_assert/rt }; }); -System.register("angular2/src/core/compiler/component_url_mapper", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { +System.register("angular2/src/core/compiler/component_url_mapper", ["angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/component_url_mapper"; - var assert, - Injectable, + var Injectable, Type, isPresent, Map, @@ -17489,8 +12028,6 @@ System.register("angular2/src/core/compiler/component_url_mapper", ["rtts_assert RuntimeComponentUrlMapper; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injectable = $__m.Injectable; }, function($__m) { Type = $__m.Type; @@ -17503,8 +12040,7 @@ System.register("angular2/src/core/compiler/component_url_mapper", ["rtts_assert ComponentUrlMapper = (function() { function ComponentUrlMapper() {} return ($traceurRuntime.createClass)(ComponentUrlMapper, {getUrl: function(component) { - assert.argumentTypes(component, Type); - return assert.returnType(('./'), assert.type.string); + return './'; }}, {}); }()); $__export("ComponentUrlMapper", ComponentUrlMapper); @@ -17521,15 +12057,13 @@ System.register("angular2/src/core/compiler/component_url_mapper", ["rtts_assert } return ($traceurRuntime.createClass)(RuntimeComponentUrlMapper, { setComponentUrl: function(component, url) { - assert.argumentTypes(component, Type, url, assert.type.string); MapWrapper.set(this._componentUrls, component, url); }, getUrl: function(component) { - assert.argumentTypes(component, Type); var url = MapWrapper.get(this._componentUrls, component); if (isPresent(url)) - return assert.returnType((url), assert.type.string); - return assert.returnType(($traceurRuntime.superGet(this, RuntimeComponentUrlMapper.prototype, "getUrl").call(this, component)), assert.type.string); + return url; + return $traceurRuntime.superGet(this, RuntimeComponentUrlMapper.prototype, "getUrl").call(this, component); } }, {}, $__super); }(ComponentUrlMapper)); @@ -17544,11 +12078,10 @@ System.register("angular2/src/core/compiler/component_url_mapper", ["rtts_assert }; }); -System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/reflection/reflection", "angular2/change_detection", "angular2/src/core/annotations_impl/annotations", "angular2/src/render/api", "angular2/src/core/compiler/view", "angular2/src/core/compiler/element_injector"], function($__export) { +System.register("angular2/src/core/compiler/proto_view_factory", ["angular2/src/di/annotations_impl", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/reflection/reflection", "angular2/change_detection", "angular2/src/core/annotations_impl/annotations", "angular2/src/render/api", "angular2/src/core/compiler/view", "angular2/src/core/compiler/element_injector"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/proto_view_factory"; - var assert, - Injectable, + var Injectable, List, ListWrapper, MapWrapper, @@ -17557,18 +12090,20 @@ System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/r reflector, ChangeDetection, DirectiveIndex, + BindingRecord, + DirectiveRecord, + ProtoChangeDetector, Component, renderApi, AppProtoView, ProtoElementInjector, DirectiveBinding, + BindingRecordsCreator, ProtoViewFactory, SortedDirectives, ParentProtoElementInjectorWithDistance; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injectable = $__m.Injectable; }, function($__m) { List = $__m.List; @@ -17582,6 +12117,9 @@ System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/r }, function($__m) { ChangeDetection = $__m.ChangeDetection; DirectiveIndex = $__m.DirectiveIndex; + BindingRecord = $__m.BindingRecord; + DirectiveRecord = $__m.DirectiveRecord; + ProtoChangeDetector = $__m.ProtoChangeDetector; }, function($__m) { Component = $__m.Component; }, function($__m) { @@ -17593,34 +12131,160 @@ System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/r DirectiveBinding = $__m.DirectiveBinding; }], execute: function() { + BindingRecordsCreator = (function() { + function BindingRecordsCreator() { + this._directiveRecordsMap = MapWrapper.create(); + this._textNodeIndex = 0; + } + return ($traceurRuntime.createClass)(BindingRecordsCreator, { + getBindingRecords: function(elementBinders, sortedDirectives) { + var bindings = []; + for (var boundElementIndex = 0; boundElementIndex < elementBinders.length; boundElementIndex++) { + var renderElementBinder = elementBinders[boundElementIndex]; + bindings = ListWrapper.concat(bindings, this._createTextNodeRecords(renderElementBinder)); + bindings = ListWrapper.concat(bindings, this._createElementPropertyRecords(boundElementIndex, renderElementBinder)); + bindings = ListWrapper.concat(bindings, this._createDirectiveRecords(boundElementIndex, sortedDirectives[boundElementIndex])); + } + return bindings; + }, + getDirectiveRecords: function(sortedDirectives) { + var directiveRecords = []; + for (var elementIndex = 0; elementIndex < sortedDirectives.length; ++elementIndex) { + var dirs = sortedDirectives[elementIndex].directives; + for (var dirIndex = 0; dirIndex < dirs.length; ++dirIndex) { + ListWrapper.push(directiveRecords, this._getDirectiveRecord(elementIndex, dirIndex, dirs[dirIndex])); + } + } + return directiveRecords; + }, + _createTextNodeRecords: function(renderElementBinder) { + var $__0 = this; + if (isBlank(renderElementBinder.textBindings)) + return []; + return ListWrapper.map(renderElementBinder.textBindings, (function(b) { + return BindingRecord.createForTextNode(b, $__0._textNodeIndex++); + })); + }, + _createElementPropertyRecords: function(boundElementIndex, renderElementBinder) { + var res = []; + MapWrapper.forEach(renderElementBinder.propertyBindings, (function(astWithSource, propertyName) { + ListWrapper.push(res, BindingRecord.createForElement(astWithSource, boundElementIndex, propertyName)); + })); + return res; + }, + _createDirectiveRecords: function(boundElementIndex, sortedDirectives) { + var $__0 = this; + var res = []; + for (var i = 0; i < sortedDirectives.renderDirectives.length; i++) { + var directiveBinder = sortedDirectives.renderDirectives[i]; + MapWrapper.forEach(directiveBinder.propertyBindings, (function(astWithSource, propertyName) { + var setter = reflector.setter(propertyName); + var directiveRecord = $__0._getDirectiveRecord(boundElementIndex, i, sortedDirectives.directives[i]); + var b = BindingRecord.createForDirective(astWithSource, propertyName, setter, directiveRecord); + ListWrapper.push(res, b); + })); + MapWrapper.forEach(directiveBinder.hostPropertyBindings, (function(astWithSource, propertyName) { + var dirIndex = new DirectiveIndex(boundElementIndex, i); + var b = BindingRecord.createForHostProperty(dirIndex, astWithSource, propertyName); + ListWrapper.push(res, b); + })); + } + return res; + }, + _getDirectiveRecord: function(boundElementIndex, directiveIndex, binding) { + var id = boundElementIndex * 100 + directiveIndex; + if (!MapWrapper.contains(this._directiveRecordsMap, id)) { + var changeDetection = binding.changeDetection; + MapWrapper.set(this._directiveRecordsMap, id, new DirectiveRecord(new DirectiveIndex(boundElementIndex, directiveIndex), binding.callOnAllChangesDone, binding.callOnChange, changeDetection)); + } + return MapWrapper.get(this._directiveRecordsMap, id); + } + }, {}); + }()); + Object.defineProperty(BindingRecordsCreator.prototype.getBindingRecords, "parameters", {get: function() { + return [[assert.genericType(List, renderApi.ElementBinder)], [assert.genericType(List, SortedDirectives)]]; + }}); + Object.defineProperty(BindingRecordsCreator.prototype.getDirectiveRecords, "parameters", {get: function() { + return [[assert.genericType(List, SortedDirectives)]]; + }}); + Object.defineProperty(BindingRecordsCreator.prototype._createTextNodeRecords, "parameters", {get: function() { + return [[renderApi.ElementBinder]]; + }}); + Object.defineProperty(BindingRecordsCreator.prototype._createElementPropertyRecords, "parameters", {get: function() { + return [[assert.type.number], [renderApi.ElementBinder]]; + }}); + Object.defineProperty(BindingRecordsCreator.prototype._createDirectiveRecords, "parameters", {get: function() { + return [[assert.type.number], [SortedDirectives]]; + }}); + Object.defineProperty(BindingRecordsCreator.prototype._getDirectiveRecord, "parameters", {get: function() { + return [[assert.type.number], [assert.type.number], [DirectiveBinding]]; + }}); ProtoViewFactory = (function() { function ProtoViewFactory(changeDetection) { - assert.argumentTypes(changeDetection, ChangeDetection); this._changeDetection = changeDetection; } return ($traceurRuntime.createClass)(ProtoViewFactory, { - createProtoView: function(componentBinding, renderProtoView, directives) { - assert.argumentTypes(componentBinding, DirectiveBinding, renderProtoView, renderApi.ProtoViewDto, directives, assert.genericType(List, DirectiveBinding)); - var protoChangeDetector; - if (isBlank(componentBinding)) { - protoChangeDetector = this._changeDetection.createProtoChangeDetector('root', null); - } else { - var componentAnnotation = assert.type(componentBinding.annotation, Component); - protoChangeDetector = this._changeDetection.createProtoChangeDetector('dummy', componentAnnotation.changeDetection); - } - var protoView = new AppProtoView(renderProtoView.render, protoChangeDetector); - for (var i = 0; i < renderProtoView.elementBinders.length; i++) { - var renderElementBinder = renderProtoView.elementBinders[i]; - var sortedDirectives = new SortedDirectives(renderElementBinder.directives, directives); - var parentPeiWithDistance = this._findParentProtoElementInjectorWithDistance(i, protoView.elementBinders, renderProtoView.elementBinders); - var protoElementInjector = this._createProtoElementInjector(i, parentPeiWithDistance, sortedDirectives, renderElementBinder); - this._createElementBinder(protoView, renderElementBinder, protoElementInjector, sortedDirectives); - this._createDirectiveBinders(protoView, i, sortedDirectives); - } + createProtoView: function(parentProtoView, componentBinding, renderProtoView, directives) { + var elementBinders = renderProtoView.elementBinders; + var sortedDirectives = ListWrapper.map(elementBinders, (function(b) { + return new SortedDirectives(b.directives, directives); + })); + var variableBindings = this._createVariableBindings(renderProtoView); + var protoLocals = this._createProtoLocals(variableBindings); + var variableNames = this._createVariableNames(parentProtoView, protoLocals); + var protoChangeDetector = this._createProtoChangeDetector(elementBinders, sortedDirectives, componentBinding, variableNames); + var protoView = new AppProtoView(renderProtoView.render, protoChangeDetector, variableBindings, protoLocals, variableNames); + this._createElementBinders(protoView, elementBinders, sortedDirectives); + this._bindDirectiveEvents(protoView, sortedDirectives); + return protoView; + }, + _createProtoLocals: function(varBindings) { + var protoLocals = MapWrapper.create(); + MapWrapper.forEach(varBindings, (function(mappedName, varName) { + MapWrapper.set(protoLocals, mappedName, null); + })); + return protoLocals; + }, + _createVariableBindings: function(renderProtoView) { + var variableBindings = MapWrapper.create(); MapWrapper.forEach(renderProtoView.variableBindings, (function(mappedName, varName) { - protoView.bindVariable(varName, mappedName); + MapWrapper.set(variableBindings, varName, mappedName); })); - return assert.returnType((protoView), AppProtoView); + ListWrapper.forEach(renderProtoView.elementBinders, (function(binder) { + MapWrapper.forEach(binder.variableBindings, (function(mappedName, varName) { + MapWrapper.set(variableBindings, varName, mappedName); + })); + })); + return variableBindings; + }, + _createVariableNames: function(parentProtoView, protoLocals) { + var variableNames = isPresent(parentProtoView) ? ListWrapper.clone(parentProtoView.variableNames) : []; + MapWrapper.forEach(protoLocals, (function(v, local) { + ListWrapper.push(variableNames, local); + })); + return variableNames; + }, + _createProtoChangeDetector: function(elementBinders, sortedDirectives, componentBinding, variableNames) { + var bindingRecordsCreator = new BindingRecordsCreator(); + var bindingRecords = bindingRecordsCreator.getBindingRecords(elementBinders, sortedDirectives); + var directiveRecords = bindingRecordsCreator.getDirectiveRecords(sortedDirectives); + var changeDetection = null; + var name = 'root'; + if (isPresent(componentBinding)) { + var componentAnnotation = componentBinding.annotation; + changeDetection = componentAnnotation.changeDetection; + name = 'dummy'; + } + return this._changeDetection.createProtoChangeDetector(name, bindingRecords, variableNames, directiveRecords, changeDetection); + }, + _createElementBinders: function(protoView, elementBinders, sortedDirectives) { + for (var i = 0; i < elementBinders.length; i++) { + var renderElementBinder = elementBinders[i]; + var dirs = sortedDirectives[i]; + var parentPeiWithDistance = this._findParentProtoElementInjectorWithDistance(i, protoView.elementBinders, elementBinders); + var protoElementInjector = this._createProtoElementInjector(i, parentPeiWithDistance, dirs, renderElementBinder); + this._createElementBinder(protoView, i, renderElementBinder, protoElementInjector, dirs); + } }, _findParentProtoElementInjectorWithDistance: function(binderIndex, elementBinders, renderElementBinders) { var distance = 0; @@ -17654,36 +12318,25 @@ System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/r } return protoElementInjector; }, - _createElementBinder: function(protoView, renderElementBinder, protoElementInjector, sortedDirectives) { + _createElementBinder: function(protoView, boundElementIndex, renderElementBinder, protoElementInjector, sortedDirectives) { var parent = null; if (renderElementBinder.parentIndex !== -1) { parent = protoView.elementBinders[renderElementBinder.parentIndex]; } var elBinder = protoView.bindElement(parent, renderElementBinder.distanceToParent, protoElementInjector, sortedDirectives.componentDirective); - for (var i = 0; i < renderElementBinder.textBindings.length; i++) { - protoView.bindTextNode(renderElementBinder.textBindings[i]); - } - MapWrapper.forEach(renderElementBinder.propertyBindings, (function(astWithSource, propertyName) { - protoView.bindElementProperty(astWithSource, propertyName); - })); - protoView.bindEvent(renderElementBinder.eventBindings, -1); + protoView.bindEvent(renderElementBinder.eventBindings, boundElementIndex, -1); MapWrapper.forEach(renderElementBinder.variableBindings, (function(mappedName, varName) { MapWrapper.set(protoView.protoLocals, mappedName, null); })); return elBinder; }, - _createDirectiveBinders: function(protoView, boundElementIndex, sortedDirectives) { - for (var i = 0; i < sortedDirectives.renderDirectives.length; i++) { - var directiveBinder = sortedDirectives.renderDirectives[i]; - MapWrapper.forEach(directiveBinder.propertyBindings, (function(astWithSource, propertyName) { - var setter = reflector.setter(propertyName); - protoView.bindDirectiveProperty(i, astWithSource, propertyName, setter); - })); - MapWrapper.forEach(directiveBinder.hostPropertyBindings, (function(astWithSource, propertyName) { - var directiveIndex = new DirectiveIndex(boundElementIndex, i); - protoView.bindHostElementProperty(astWithSource, propertyName, directiveIndex); - })); - protoView.bindEvent(directiveBinder.eventBindings, i); + _bindDirectiveEvents: function(protoView, sortedDirectives) { + for (var boundElementIndex = 0; boundElementIndex < sortedDirectives.length; ++boundElementIndex) { + var dirs = sortedDirectives[boundElementIndex].renderDirectives; + for (var i = 0; i < dirs.length; i++) { + var directiveBinder = dirs[i]; + protoView.bindEvent(directiveBinder.eventBindings, boundElementIndex, i); + } } } }, {}); @@ -17696,7 +12349,13 @@ System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/r return [[ChangeDetection]]; }}); Object.defineProperty(ProtoViewFactory.prototype.createProtoView, "parameters", {get: function() { - return [[DirectiveBinding], [renderApi.ProtoViewDto], [assert.genericType(List, DirectiveBinding)]]; + return [[AppProtoView], [DirectiveBinding], [renderApi.ProtoViewDto], [assert.genericType(List, DirectiveBinding)]]; + }}); + Object.defineProperty(ProtoViewFactory.prototype._createProtoLocals, "parameters", {get: function() { + return [[Map]]; + }}); + Object.defineProperty(ProtoViewFactory.prototype._bindDirectiveEvents, "parameters", {get: function() { + return [[], [assert.genericType(List, SortedDirectives)]]; }}); SortedDirectives = (function() { function SortedDirectives(renderDirectives, allDirectives) { @@ -17720,7 +12379,6 @@ System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/r }()); ParentProtoElementInjectorWithDistance = (function() { function ParentProtoElementInjectorWithDistance(protoElementInjector, distance) { - assert.argumentTypes(protoElementInjector, ProtoElementInjector, distance, assert.type.number); this.protoElementInjector = protoElementInjector; this.distance = distance; } @@ -17733,7 +12391,66 @@ System.register("angular2/src/core/compiler/proto_view_factory", ["rtts_assert/r }; }); -System.register("angular2/src/core/exception_handler", ["angular2/di", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { +System.register("angular2/src/services/url_resolver", ["angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/services/url_resolver"; + var Injectable, + isPresent, + isBlank, + RegExpWrapper, + BaseException, + DOM, + UrlResolver, + _schemeRe; + return { + setters: [function($__m) { + Injectable = $__m.Injectable; + }, function($__m) { + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + RegExpWrapper = $__m.RegExpWrapper; + BaseException = $__m.BaseException; + }, function($__m) { + DOM = $__m.DOM; + }], + execute: function() { + UrlResolver = (function() { + function UrlResolver() { + if (isBlank(UrlResolver.a)) { + UrlResolver.a = DOM.createElement('a'); + } + } + return ($traceurRuntime.createClass)(UrlResolver, {resolve: function(baseUrl, url) { + if (isBlank(baseUrl)) { + DOM.resolveAndSetHref(UrlResolver.a, url, null); + return DOM.getHref(UrlResolver.a); + } + if (isBlank(url) || url == '') + return baseUrl; + if (url[0] == '/') { + throw new BaseException(("Could not resolve the url " + url + " from " + baseUrl)); + } + var m = RegExpWrapper.firstMatch(_schemeRe, url); + if (isPresent(m[1])) { + return url; + } + DOM.resolveAndSetHref(UrlResolver.a, baseUrl, url); + return DOM.getHref(UrlResolver.a); + }}, {}); + }()); + $__export("UrlResolver", UrlResolver); + Object.defineProperty(UrlResolver, "annotations", {get: function() { + return [new Injectable()]; + }}); + Object.defineProperty(UrlResolver.prototype.resolve, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string]]; + }}); + _schemeRe = RegExpWrapper.create('^([^:/?#]+:)?'); + } + }; +}); + +System.register("angular2/src/core/exception_handler", ["angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/exception_handler"; var Injectable, @@ -17741,6 +12458,7 @@ System.register("angular2/src/core/exception_handler", ["angular2/di", "angular2 print, ListWrapper, isListLikeIterable, + DOM, ExceptionHandler; return { setters: [function($__m) { @@ -17751,6 +12469,8 @@ System.register("angular2/src/core/exception_handler", ["angular2/di", "angular2 }, function($__m) { ListWrapper = $__m.ListWrapper; isListLikeIterable = $__m.isListLikeIterable; + }, function($__m) { + DOM = $__m.DOM; }], execute: function() { ExceptionHandler = (function() { @@ -17760,7 +12480,7 @@ System.register("angular2/src/core/exception_handler", ["angular2/di", "angular2 var reason = arguments[2] !== (void 0) ? arguments[2] : null; var longStackTrace = isListLikeIterable(stackTrace) ? ListWrapper.join(stackTrace, "\n\n") : stackTrace; var reasonStr = isPresent(reason) ? ("\n" + reason) : ''; - print(("" + error + reasonStr + "\nSTACKTRACE:\n" + longStackTrace)); + DOM.logError(("" + error + reasonStr + "\nSTACKTRACE:\n" + longStackTrace)); }}, {}); }()); $__export("ExceptionHandler", ExceptionHandler); @@ -17771,25 +12491,170 @@ System.register("angular2/src/core/exception_handler", ["angular2/di", "angular2 }; }); -System.register("angular2/src/core/life_cycle/life_cycle", ["rtts_assert/rtts_assert", "angular2/di", "angular2/change_detection", "angular2/src/core/zone/vm_turn_zone", "angular2/src/core/exception_handler", "angular2/src/facade/lang"], function($__export) { +System.register("angular2/src/services/xhr", ["angular2/src/facade/async"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/services/xhr"; + var Promise, + XHR; + return { + setters: [function($__m) { + Promise = $__m.Promise; + }], + execute: function() { + XHR = (function() { + function XHR() {} + return ($traceurRuntime.createClass)(XHR, {get: function(url) { + return null; + }}, {}); + }()); + $__export("XHR", XHR); + Object.defineProperty(XHR.prototype.get, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + } + }; +}); + +System.register("angular2/src/core/zone/ng_zone", ["angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/zone/ng_zone"; + var List, + ListWrapper, + StringMapWrapper, + normalizeBlank, + isPresent, + global, + NgZone; + return { + setters: [function($__m) { + List = $__m.List; + ListWrapper = $__m.ListWrapper; + StringMapWrapper = $__m.StringMapWrapper; + }, function($__m) { + normalizeBlank = $__m.normalizeBlank; + isPresent = $__m.isPresent; + global = $__m.global; + }], + execute: function() { + NgZone = (function() { + function NgZone($__1) { + var enableLongStackTrace = $__1.enableLongStackTrace; + this._onTurnStart = null; + this._onTurnDone = null; + this._onErrorHandler = null; + this._pendingMicrotasks = 0; + this._hasExecutedCodeInInnerZone = false; + this._nestedRun = 0; + this._mountZone = global.zone; + this._innerZone = this._createInnerZone(this._mountZone, enableLongStackTrace); + } + return ($traceurRuntime.createClass)(NgZone, { + initCallbacks: function() { + var $__1 = arguments[0] !== (void 0) ? arguments[0] : {}, + onTurnStart = $__1.onTurnStart, + onTurnDone = $__1.onTurnDone, + onErrorHandler = $__1.onErrorHandler; + this._onTurnStart = normalizeBlank(onTurnStart); + this._onTurnDone = normalizeBlank(onTurnDone); + this._onErrorHandler = normalizeBlank(onErrorHandler); + }, + run: function(fn) { + return this._innerZone.run(fn); + }, + runOutsideAngular: function(fn) { + return this._mountZone.run(fn); + }, + _createInnerZone: function(zone, enableLongStackTrace) { + var ngZone = this; + var errorHandling; + if (enableLongStackTrace) { + errorHandling = StringMapWrapper.merge(Zone.longStackTraceZone, {onError: function(e) { + ngZone._onError(this, e); + }}); + } else { + errorHandling = {onError: function(e) { + ngZone._onError(this, e); + }}; + } + return zone.fork(errorHandling).fork({ + '$run': function(parentRun) { + return function() { + try { + ngZone._nestedRun++; + if (!ngZone._hasExecutedCodeInInnerZone) { + ngZone._hasExecutedCodeInInnerZone = true; + if (ngZone._onTurnStart) { + parentRun.call(ngZone._innerZone, ngZone._onTurnStart); + } + } + return parentRun.apply(this, arguments); + } finally { + ngZone._nestedRun--; + if (ngZone._pendingMicrotasks == 0 && ngZone._nestedRun == 0) { + if (ngZone._onTurnDone && ngZone._hasExecutedCodeInInnerZone) { + try { + parentRun.call(ngZone._innerZone, ngZone._onTurnDone); + } finally { + ngZone._hasExecutedCodeInInnerZone = false; + } + } + } + } + }; + }, + '$scheduleMicrotask': function(parentScheduleMicrotask) { + return function(fn) { + ngZone._pendingMicrotasks++; + var microtask = function() { + try { + fn(); + } finally { + ngZone._pendingMicrotasks--; + } + }; + parentScheduleMicrotask.call(this, microtask); + }; + }, + _innerZone: true + }); + }, + _onError: function(zone, e) { + if (isPresent(this._onErrorHandler)) { + var trace = [normalizeBlank(e.stack)]; + while (zone && zone.constructedAtException) { + trace.push(zone.constructedAtException.get()); + zone = zone.parent; + } + this._onErrorHandler(e, trace); + } else { + console.log('## _onError ##'); + console.log(e.stack); + throw e; + } + } + }, {}); + }()); + $__export("NgZone", NgZone); + } + }; +}); + +System.register("angular2/src/core/life_cycle/life_cycle", ["angular2/src/di/annotations_impl", "angular2/change_detection", "angular2/src/core/zone/ng_zone", "angular2/src/core/exception_handler", "angular2/src/facade/lang"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/life_cycle/life_cycle"; - var assert, - Injectable, + var Injectable, ChangeDetector, - VmTurnZone, + NgZone, ExceptionHandler, isPresent, LifeCycle; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injectable = $__m.Injectable; }, function($__m) { ChangeDetector = $__m.ChangeDetector; }, function($__m) { - VmTurnZone = $__m.VmTurnZone; + NgZone = $__m.NgZone; }, function($__m) { ExceptionHandler = $__m.ExceptionHandler; }, function($__m) { @@ -17800,7 +12665,6 @@ System.register("angular2/src/core/life_cycle/life_cycle", ["rtts_assert/rtts_as function LifeCycle(exceptionHandler) { var changeDetector = arguments[1] !== (void 0) ? arguments[1] : null; var enforceNoNewChanges = arguments[2] !== (void 0) ? arguments[2] : false; - assert.argumentTypes(exceptionHandler, ExceptionHandler, changeDetector, ChangeDetector, enforceNoNewChanges, assert.type.boolean); this._errorHandler = (function(exception, stackTrace) { exceptionHandler.call(exception, stackTrace); throw exception; @@ -17822,33 +12686,85 @@ System.register("angular2/src/core/life_cycle/life_cycle", ["rtts_assert/rtts_as }) }); }, - tick: function() { - this._changeDetector.detectChanges(); - if (this._enforceNoNewChanges) { - this._changeDetector.checkNoChanges(); - } - } + tick: function() { + this._changeDetector.detectChanges(); + if (this._enforceNoNewChanges) { + this._changeDetector.checkNoChanges(); + } + } + }, {}); + }()); + $__export("LifeCycle", LifeCycle); + Object.defineProperty(LifeCycle, "annotations", {get: function() { + return [new Injectable()]; + }}); + Object.defineProperty(LifeCycle, "parameters", {get: function() { + return [[ExceptionHandler], [ChangeDetector], [assert.type.boolean]]; + }}); + Object.defineProperty(LifeCycle.prototype.registerWith, "parameters", {get: function() { + return [[NgZone], [ChangeDetector]]; + }}); + } + }; +}); + +System.register("angular2/src/render/dom/shadow_dom/shadow_dom_strategy", ["angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/light_dom"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"; + var isBlank, + isPresent, + Promise, + viewModule, + LightDom, + ShadowDomStrategy; + return { + setters: [function($__m) { + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + }, function($__m) { + Promise = $__m.Promise; + }, function($__m) { + viewModule = $__m; + }, function($__m) { + LightDom = $__m.LightDom; + }], + execute: function() { + ShadowDomStrategy = (function() { + function ShadowDomStrategy() {} + return ($traceurRuntime.createClass)(ShadowDomStrategy, { + hasNativeContentElement: function() { + return true; + }, + prepareShadowRoot: function(el) { + return null; + }, + constructLightDom: function(lightDomView, el) { + return null; + }, + processStyleElement: function(hostComponentId, templateUrl, styleElement) { + return null; + }, + processElement: function(hostComponentId, elementComponentId, element) {} }, {}); }()); - $__export("LifeCycle", LifeCycle); - Object.defineProperty(LifeCycle, "annotations", {get: function() { - return [new Injectable()]; + $__export("ShadowDomStrategy", ShadowDomStrategy); + Object.defineProperty(ShadowDomStrategy.prototype.constructLightDom, "parameters", {get: function() { + return [[viewModule.DomView], []]; }}); - Object.defineProperty(LifeCycle, "parameters", {get: function() { - return [[ExceptionHandler], [ChangeDetector], [assert.type.boolean]]; + Object.defineProperty(ShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], []]; }}); - Object.defineProperty(LifeCycle.prototype.registerWith, "parameters", {get: function() { - return [[VmTurnZone], [ChangeDetector]]; + Object.defineProperty(ShadowDomStrategy.prototype.processElement, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], []]; }}); } }; }); -System.register("angular2/src/render/dom/shadow_dom/style_url_resolver", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/services/url_resolver"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/style_url_resolver", ["angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/services/url_resolver"], function($__export) { "use strict"; var __moduleName = "angular2/src/render/dom/shadow_dom/style_url_resolver"; - var assert, - Injectable, + var Injectable, RegExp, RegExpWrapper, StringWrapper, @@ -17859,8 +12775,6 @@ System.register("angular2/src/render/dom/shadow_dom/style_url_resolver", ["rtts_ _quoteRe; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injectable = $__m.Injectable; }, function($__m) { RegExp = $__m.RegExp; @@ -17872,19 +12786,16 @@ System.register("angular2/src/render/dom/shadow_dom/style_url_resolver", ["rtts_ execute: function() { StyleUrlResolver = (function() { function StyleUrlResolver(resolver) { - assert.argumentTypes(resolver, UrlResolver); this._resolver = resolver; } return ($traceurRuntime.createClass)(StyleUrlResolver, { resolveUrls: function(cssText, baseUrl) { - assert.argumentTypes(cssText, assert.type.string, baseUrl, assert.type.string); cssText = this._replaceUrls(cssText, _cssUrlRe, baseUrl); cssText = this._replaceUrls(cssText, _cssImportRe, baseUrl); return cssText; }, _replaceUrls: function(cssText, re, baseUrl) { var $__0 = this; - assert.argumentTypes(cssText, assert.type.string, re, RegExp, baseUrl, assert.type.string); return StringWrapper.replaceAllMapped(cssText, re, (function(m) { var pre = m[1]; var url = StringWrapper.replaceAll(m[2], _quoteRe, ''); @@ -17915,11 +12826,10 @@ System.register("angular2/src/render/dom/shadow_dom/style_url_resolver", ["rtts_ }; }); -System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/rtts_assert", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { "use strict"; var __moduleName = "angular2/src/render/dom/shadow_dom/shadow_css"; - var assert, - DOM, + var DOM, List, ListWrapper, StringWrapper, @@ -17946,11 +12856,9 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r _colonHostRe, _colonHostContextRe; function _cssToRules(cssText) { - assert.argumentTypes(cssText, assert.type.string); return DOM.cssToRules(cssText); } function _withCssRules(cssText, callback) { - assert.argumentTypes(cssText, assert.type.string, callback, Function); if (isBlank(callback)) return ; var rules = _cssToRules(cssText); @@ -17958,8 +12866,6 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { DOM = $__m.DOM; }, function($__m) { List = $__m.List; @@ -17982,39 +12888,33 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r return ($traceurRuntime.createClass)(ShadowCss, { shimStyle: function(style, selector) { var hostSelector = arguments[2] !== (void 0) ? arguments[2] : ''; - assert.argumentTypes(style, assert.type.any, selector, assert.type.string, hostSelector, assert.type.string); var cssText = DOM.getText(style); - return assert.returnType((this.shimCssText(cssText, selector, hostSelector)), assert.type.string); + return this.shimCssText(cssText, selector, hostSelector); }, shimCssText: function(cssText, selector) { var hostSelector = arguments[2] !== (void 0) ? arguments[2] : ''; - assert.argumentTypes(cssText, assert.type.string, selector, assert.type.string, hostSelector, assert.type.string); cssText = this._insertDirectives(cssText); - return assert.returnType((this._scopeCssText(cssText, selector, hostSelector)), assert.type.string); + return this._scopeCssText(cssText, selector, hostSelector); }, _insertDirectives: function(cssText) { - assert.argumentTypes(cssText, assert.type.string); cssText = this._insertPolyfillDirectivesInCssText(cssText); - return assert.returnType((this._insertPolyfillRulesInCssText(cssText)), assert.type.string); + return this._insertPolyfillRulesInCssText(cssText); }, _insertPolyfillDirectivesInCssText: function(cssText) { - assert.argumentTypes(cssText, assert.type.string); - return assert.returnType((StringWrapper.replaceAllMapped(cssText, _cssContentNextSelectorRe, function(m) { + return StringWrapper.replaceAllMapped(cssText, _cssContentNextSelectorRe, function(m) { return m[1] + '{'; - })), assert.type.string); + }); }, _insertPolyfillRulesInCssText: function(cssText) { - assert.argumentTypes(cssText, assert.type.string); - return assert.returnType((StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function(m) { + return StringWrapper.replaceAllMapped(cssText, _cssContentRuleRe, function(m) { var rule = m[0]; rule = StringWrapper.replace(rule, m[1], ''); rule = StringWrapper.replace(rule, m[2], ''); return m[3] + rule; - })), assert.type.string); + }); }, _scopeCssText: function(cssText, scopeSelector, hostSelector) { var $__0 = this; - assert.argumentTypes(cssText, assert.type.string, scopeSelector, assert.type.string, hostSelector, assert.type.string); var unscoped = this._extractUnscopedRulesFromCssText(cssText); cssText = this._insertPolyfillHostInCssText(cssText); cssText = this._convertColonHost(cssText); @@ -18026,10 +12926,9 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r })); } cssText = cssText + '\n' + unscoped; - return assert.returnType((cssText.trim()), assert.type.string); + return cssText.trim(); }, _extractUnscopedRulesFromCssText: function(cssText) { - assert.argumentTypes(cssText, assert.type.string); var r = '', m; var matcher = RegExpWrapper.matcher(_cssContentUnscopedRuleRe, cssText); @@ -18039,19 +12938,16 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r rule = StringWrapper.replace(rule, m[1], m[3]); r = rule + '\n\n'; } - return assert.returnType((r), assert.type.string); + return r; }, _convertColonHost: function(cssText) { - assert.argumentTypes(cssText, assert.type.string); - return assert.returnType((this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer)), assert.type.string); + return this._convertColonRule(cssText, _cssColonHostRe, this._colonHostPartReplacer); }, _convertColonHostContext: function(cssText) { - assert.argumentTypes(cssText, assert.type.string); - return assert.returnType((this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer)), assert.type.string); + return this._convertColonRule(cssText, _cssColonHostContextRe, this._colonHostContextPartReplacer); }, _convertColonRule: function(cssText, regExp, partReplacer) { - assert.argumentTypes(cssText, assert.type.string, regExp, RegExp, partReplacer, Function); - return assert.returnType((StringWrapper.replaceAllMapped(cssText, regExp, function(m) { + return StringWrapper.replaceAllMapped(cssText, regExp, function(m) { if (isPresent(m[2])) { var parts = m[2].split(','), r = []; @@ -18066,29 +12962,25 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r } else { return _polyfillHostNoCombinator + m[3]; } - })), assert.type.string); + }); }, _colonHostContextPartReplacer: function(host, part, suffix) { - assert.argumentTypes(host, assert.type.string, part, assert.type.string, suffix, assert.type.string); if (StringWrapper.contains(part, _polyfillHost)) { - return assert.returnType((this._colonHostPartReplacer(host, part, suffix)), assert.type.string); + return this._colonHostPartReplacer(host, part, suffix); } else { - return assert.returnType((host + part + suffix + ', ' + part + ' ' + host + suffix), assert.type.string); + return host + part + suffix + ', ' + part + ' ' + host + suffix; } }, _colonHostPartReplacer: function(host, part, suffix) { - assert.argumentTypes(host, assert.type.string, part, assert.type.string, suffix, assert.type.string); - return assert.returnType((host + StringWrapper.replace(part, _polyfillHost, '') + suffix), assert.type.string); + return host + StringWrapper.replace(part, _polyfillHost, '') + suffix; }, _convertShadowDOMSelectors: function(cssText) { - assert.argumentTypes(cssText, assert.type.string); for (var i = 0; i < _shadowDOMSelectorsRe.length; i++) { cssText = StringWrapper.replaceAll(cssText, _shadowDOMSelectorsRe[i], ' '); } - return assert.returnType((cssText), assert.type.string); + return cssText; }, _scopeRules: function(cssRules, scopeSelector, hostSelector) { - assert.argumentTypes(cssRules, assert.type.any, scopeSelector, assert.type.string, hostSelector, assert.type.string); var cssText = ''; if (isPresent(cssRules)) { for (var i = 0; i < cssRules.length; i++) { @@ -18113,7 +13005,7 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r } } } - return assert.returnType((cssText), assert.type.string); + return cssText; }, _ieSafeCssTextFromKeyFrameRule: function(rule) { var cssText = '@keyframes ' + rule.name + ' {'; @@ -18122,10 +13014,9 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r cssText += ' ' + r.keyText + ' {' + r.style.cssText + '}'; } cssText += ' }'; - return assert.returnType((cssText), assert.type.string); + return cssText; }, _scopeSelector: function(selector, scopeSelector, hostSelector, strict) { - assert.argumentTypes(selector, assert.type.string, scopeSelector, assert.type.string, hostSelector, assert.type.string, strict, assert.type.boolean); var r = [], parts = selector.split(','); for (var i = 0; i < parts.length; i++) { @@ -18136,33 +13027,29 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r } ListWrapper.push(r, p); } - return assert.returnType((r.join(', ')), assert.type.string); + return r.join(', '); }, _selectorNeedsScoping: function(selector, scopeSelector) { - assert.argumentTypes(selector, assert.type.string, scopeSelector, assert.type.string); var re = this._makeScopeMatcher(scopeSelector); - return assert.returnType((!isPresent(RegExpWrapper.firstMatch(re, selector))), assert.type.boolean); + return !isPresent(RegExpWrapper.firstMatch(re, selector)); }, _makeScopeMatcher: function(scopeSelector) { - assert.argumentTypes(scopeSelector, assert.type.string); var lre = RegExpWrapper.create('\\['); var rre = RegExpWrapper.create('\\]'); scopeSelector = StringWrapper.replaceAll(scopeSelector, lre, '\\['); scopeSelector = StringWrapper.replaceAll(scopeSelector, rre, '\\]'); - return assert.returnType((RegExpWrapper.create('^(' + scopeSelector + ')' + _selectorReSuffix, 'm')), RegExp); + return RegExpWrapper.create('^(' + scopeSelector + ')' + _selectorReSuffix, 'm'); }, _applySelectorScope: function(selector, scopeSelector, hostSelector) { - assert.argumentTypes(selector, assert.type.string, scopeSelector, assert.type.string, hostSelector, assert.type.string); - return assert.returnType((this._applySimpleSelectorScope(selector, scopeSelector, hostSelector)), assert.type.string); + return this._applySimpleSelectorScope(selector, scopeSelector, hostSelector); }, _applySimpleSelectorScope: function(selector, scopeSelector, hostSelector) { - assert.argumentTypes(selector, assert.type.string, scopeSelector, assert.type.string, hostSelector, assert.type.string); if (isPresent(RegExpWrapper.firstMatch(_polyfillHostRe, selector))) { var replaceBy = this.strictStyling ? ("[" + hostSelector + "]") : scopeSelector; selector = StringWrapper.replace(selector, _polyfillHostNoCombinator, replaceBy); - return assert.returnType((StringWrapper.replaceAll(selector, _polyfillHostRe, replaceBy + ' ')), assert.type.string); + return StringWrapper.replaceAll(selector, _polyfillHostRe, replaceBy + ' '); } else { - return assert.returnType((scopeSelector + ' ' + selector), assert.type.string); + return scopeSelector + ' ' + selector; } }, _applyStrictSelectorScope: function(selector, scopeSelector) { @@ -18188,13 +13075,12 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r return p; }).join(sep); } - return assert.returnType((scoped), assert.type.string); + return scoped; }, _insertPolyfillHostInCssText: function(selector) { - assert.argumentTypes(selector, assert.type.string); selector = StringWrapper.replaceAll(selector, _colonHostContextRe, _polyfillHostContext); selector = StringWrapper.replaceAll(selector, _colonHostRe, _polyfillHost); - return assert.returnType((selector), assert.type.string); + return selector; }, _propertiesFromRule: function(rule) { var cssText = rule.style.cssText; @@ -18203,7 +13089,7 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r var contentRe = RegExpWrapper.create('content:[^;]*;'); cssText = StringWrapper.replaceAll(cssText, contentRe, 'content: \'' + rule.style.content + '\';'); } - return assert.returnType((cssText), assert.type.string); + return cssText; } }, {}); }()); @@ -18235,4583 +13121,5304 @@ System.register("angular2/src/render/dom/shadow_dom/shadow_css", ["rtts_assert/r Object.defineProperty(ShadowCss.prototype._convertColonHostContext, "parameters", {get: function() { return [[assert.type.string]]; }}); - Object.defineProperty(ShadowCss.prototype._convertColonRule, "parameters", {get: function() { - return [[assert.type.string], [RegExp], [Function]]; - }}); - Object.defineProperty(ShadowCss.prototype._colonHostContextPartReplacer, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; + Object.defineProperty(ShadowCss.prototype._convertColonRule, "parameters", {get: function() { + return [[assert.type.string], [RegExp], [Function]]; + }}); + Object.defineProperty(ShadowCss.prototype._colonHostContextPartReplacer, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._colonHostPartReplacer, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._convertShadowDOMSelectors, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._scopeRules, "parameters", {get: function() { + return [[], [assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._scopeSelector, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.type.string], [assert.type.boolean]]; + }}); + Object.defineProperty(ShadowCss.prototype._selectorNeedsScoping, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._makeScopeMatcher, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._applySelectorScope, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._applySimpleSelectorScope, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._applyStrictSelectorScope, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(ShadowCss.prototype._insertPolyfillHostInCssText, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + _cssContentNextSelectorRe = RegExpWrapper.create('polyfill-next-selector[^}]*content:[\\s]*?[\'"](.*?)[\'"][;\\s]*}([^{]*?){', 'im'); + _cssContentRuleRe = RegExpWrapper.create('(polyfill-rule)[^}]*(content:[\\s]*[\'"](.*?)[\'"])[;\\s]*[^}]*}', 'im'); + _cssContentUnscopedRuleRe = RegExpWrapper.create('(polyfill-unscoped-rule)[^}]*(content:[\\s]*[\'"](.*?)[\'"])[;\\s]*[^}]*}', 'im'); + _polyfillHost = '-shadowcsshost'; + _polyfillHostContext = '-shadowcsscontext'; + _parenSuffix = ')(?:\\((' + '(?:\\([^)(]*\\)|[^)(]*)+?' + ')\\))?([^,{]*)'; + _cssColonHostRe = RegExpWrapper.create('(' + _polyfillHost + _parenSuffix, 'im'); + _cssColonHostContextRe = RegExpWrapper.create('(' + _polyfillHostContext + _parenSuffix, 'im'); + _polyfillHostNoCombinator = _polyfillHost + '-no-combinator'; + _shadowDOMSelectorsRe = [RegExpWrapper.create('>>>'), RegExpWrapper.create('::shadow'), RegExpWrapper.create('::content'), RegExpWrapper.create('/deep/'), RegExpWrapper.create('/shadow-deep/'), RegExpWrapper.create('/shadow/')]; + _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$'; + _polyfillHostRe = RegExpWrapper.create(_polyfillHost, 'im'); + _colonHostRe = RegExpWrapper.create(':host', 'im'); + _colonHostContextRe = RegExpWrapper.create(':host-context', 'im'); + Object.defineProperty(_cssToRules, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(_withCssRules, "parameters", {get: function() { + return [[assert.type.string], [Function]]; + }}); + } + }; +}); + +System.register("angular2/src/services/xhr_impl", ["angular2/src/di/annotations_impl", "angular2/src/facade/async", "angular2/src/services/xhr"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/services/xhr_impl"; + var Injectable, + Promise, + PromiseWrapper, + XHR, + XHRImpl; + return { + setters: [function($__m) { + Injectable = $__m.Injectable; + }, function($__m) { + Promise = $__m.Promise; + PromiseWrapper = $__m.PromiseWrapper; + }, function($__m) { + XHR = $__m.XHR; + }], + execute: function() { + XHRImpl = (function($__super) { + function XHRImpl() { + $traceurRuntime.superConstructor(XHRImpl).apply(this, arguments); + } + return ($traceurRuntime.createClass)(XHRImpl, {get: function(url) { + var completer = PromiseWrapper.completer(); + var xhr = new XMLHttpRequest(); + xhr.open('GET', url, true); + xhr.responseType = 'text'; + xhr.onload = function() { + var status = xhr.status; + if (200 <= status && status <= 300) { + completer.resolve(xhr.responseText); + } else { + completer.reject(("Failed to load " + url)); + } + }; + xhr.onerror = function() { + completer.reject(("Failed to load " + url)); + }; + xhr.send(); + return completer.promise; + }}, {}, $__super); + }(XHR)); + $__export("XHRImpl", XHRImpl); + Object.defineProperty(XHRImpl, "annotations", {get: function() { + return [new Injectable()]; + }}); + Object.defineProperty(XHRImpl.prototype.get, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + } + }; +}); + +System.register("angular2/src/render/dom/events/event_manager", ["angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/core/zone/ng_zone"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/events/event_manager"; + var isBlank, + BaseException, + isPresent, + StringWrapper, + DOM, + List, + ListWrapper, + MapWrapper, + NgZone, + BUBBLE_SYMBOL, + EventManager, + EventManagerPlugin, + DomEventsPlugin; + return { + setters: [function($__m) { + isBlank = $__m.isBlank; + BaseException = $__m.BaseException; + isPresent = $__m.isPresent; + StringWrapper = $__m.StringWrapper; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + List = $__m.List; + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + }, function($__m) { + NgZone = $__m.NgZone; + }], + execute: function() { + BUBBLE_SYMBOL = '^'; + EventManager = (function() { + function EventManager(plugins, zone) { + this._zone = zone; + this._plugins = plugins; + for (var i = 0; i < plugins.length; i++) { + plugins[i].manager = this; + } + } + return ($traceurRuntime.createClass)(EventManager, { + addEventListener: function(element, eventName, handler) { + var withoutBubbleSymbol = this._removeBubbleSymbol(eventName); + var plugin = this._findPluginFor(withoutBubbleSymbol); + plugin.addEventListener(element, withoutBubbleSymbol, handler, withoutBubbleSymbol != eventName); + }, + addGlobalEventListener: function(target, eventName, handler) { + var withoutBubbleSymbol = this._removeBubbleSymbol(eventName); + var plugin = this._findPluginFor(withoutBubbleSymbol); + return plugin.addGlobalEventListener(target, withoutBubbleSymbol, handler, withoutBubbleSymbol != eventName); + }, + getZone: function() { + return this._zone; + }, + _findPluginFor: function(eventName) { + var plugins = this._plugins; + for (var i = 0; i < plugins.length; i++) { + var plugin = plugins[i]; + if (plugin.supports(eventName)) { + return plugin; + } + } + throw new BaseException(("No event manager plugin found for event " + eventName)); + }, + _removeBubbleSymbol: function(eventName) { + return eventName[0] == BUBBLE_SYMBOL ? StringWrapper.substring(eventName, 1) : eventName; + } + }, {}); + }()); + $__export("EventManager", EventManager); + Object.defineProperty(EventManager, "parameters", {get: function() { + return [[assert.genericType(List, EventManagerPlugin)], [NgZone]]; + }}); + Object.defineProperty(EventManager.prototype.addEventListener, "parameters", {get: function() { + return [[], [assert.type.string], [Function]]; + }}); + Object.defineProperty(EventManager.prototype.addGlobalEventListener, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [Function]]; + }}); + Object.defineProperty(EventManager.prototype._findPluginFor, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(EventManager.prototype._removeBubbleSymbol, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + EventManagerPlugin = (function() { + function EventManagerPlugin() {} + return ($traceurRuntime.createClass)(EventManagerPlugin, { + supports: function(eventName) { + return false; + }, + addEventListener: function(element, eventName, handler, shouldSupportBubble) { + throw "not implemented"; + }, + addGlobalEventListener: function(element, eventName, handler, shouldSupportBubble) { + throw "not implemented"; + } + }, {}); + }()); + $__export("EventManagerPlugin", EventManagerPlugin); + Object.defineProperty(EventManagerPlugin.prototype.supports, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(EventManagerPlugin.prototype.addEventListener, "parameters", {get: function() { + return [[], [assert.type.string], [Function], [assert.type.boolean]]; }}); - Object.defineProperty(ShadowCss.prototype._colonHostPartReplacer, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; + Object.defineProperty(EventManagerPlugin.prototype.addGlobalEventListener, "parameters", {get: function() { + return [[], [assert.type.string], [Function], [assert.type.boolean]]; }}); - Object.defineProperty(ShadowCss.prototype._convertShadowDOMSelectors, "parameters", {get: function() { + DomEventsPlugin = (function($__super) { + function DomEventsPlugin() { + $traceurRuntime.superConstructor(DomEventsPlugin).apply(this, arguments); + } + return ($traceurRuntime.createClass)(DomEventsPlugin, { + supports: function(eventName) { + return true; + }, + addEventListener: function(element, eventName, handler, shouldSupportBubble) { + var outsideHandler = this._getOutsideHandler(shouldSupportBubble, element, handler, this.manager._zone); + this.manager._zone.runOutsideAngular((function() { + DOM.on(element, eventName, outsideHandler); + })); + }, + addGlobalEventListener: function(target, eventName, handler, shouldSupportBubble) { + var element = DOM.getGlobalEventTarget(target); + var outsideHandler = this._getOutsideHandler(shouldSupportBubble, element, handler, this.manager._zone); + return this.manager._zone.runOutsideAngular((function() { + return DOM.onAndCancel(element, eventName, outsideHandler); + })); + }, + _getOutsideHandler: function(shouldSupportBubble, element, handler, zone) { + return shouldSupportBubble ? DomEventsPlugin.bubbleCallback(element, handler, zone) : DomEventsPlugin.sameElementCallback(element, handler, zone); + } + }, { + sameElementCallback: function(element, handler, zone) { + return (function(event) { + if (event.target === element) { + zone.run((function() { + return handler(event); + })); + } + }); + }, + bubbleCallback: function(element, handler, zone) { + return (function(event) { + return zone.run((function() { + return handler(event); + })); + }); + } + }, $__super); + }(EventManagerPlugin)); + $__export("DomEventsPlugin", DomEventsPlugin); + Object.defineProperty(DomEventsPlugin.prototype.supports, "parameters", {get: function() { return [[assert.type.string]]; }}); - Object.defineProperty(ShadowCss.prototype._scopeRules, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.string]]; + Object.defineProperty(DomEventsPlugin.prototype.addEventListener, "parameters", {get: function() { + return [[], [assert.type.string], [Function], [assert.type.boolean]]; }}); - Object.defineProperty(ShadowCss.prototype._scopeSelector, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string], [assert.type.boolean]]; + Object.defineProperty(DomEventsPlugin.prototype.addGlobalEventListener, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [Function], [assert.type.boolean]]; }}); - Object.defineProperty(ShadowCss.prototype._selectorNeedsScoping, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; + Object.defineProperty(DomEventsPlugin.prototype._getOutsideHandler, "parameters", {get: function() { + return [[assert.type.boolean], [], [Function], [NgZone]]; }}); - Object.defineProperty(ShadowCss.prototype._makeScopeMatcher, "parameters", {get: function() { + } + }; +}); + +System.register("angular2/src/render/dom/events/key_events", ["angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/render/dom/events/event_manager"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/events/key_events"; + var DOM, + isPresent, + isBlank, + StringWrapper, + RegExpWrapper, + BaseException, + NumberWrapper, + StringMapWrapper, + ListWrapper, + EventManagerPlugin, + modifierKeys, + modifierKeyGetters, + KeyEventsPlugin; + return { + setters: [function($__m) { + DOM = $__m.DOM; + }, function($__m) { + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + StringWrapper = $__m.StringWrapper; + RegExpWrapper = $__m.RegExpWrapper; + BaseException = $__m.BaseException; + NumberWrapper = $__m.NumberWrapper; + }, function($__m) { + StringMapWrapper = $__m.StringMapWrapper; + ListWrapper = $__m.ListWrapper; + }, function($__m) { + EventManagerPlugin = $__m.EventManagerPlugin; + }], + execute: function() { + modifierKeys = ['alt', 'control', 'meta', 'shift']; + modifierKeyGetters = { + 'alt': (function(event) { + return event.altKey; + }), + 'control': (function(event) { + return event.ctrlKey; + }), + 'meta': (function(event) { + return event.metaKey; + }), + 'shift': (function(event) { + return event.shiftKey; + }) + }; + KeyEventsPlugin = (function($__super) { + function KeyEventsPlugin() { + $traceurRuntime.superConstructor(KeyEventsPlugin).call(this); + } + return ($traceurRuntime.createClass)(KeyEventsPlugin, { + supports: function(eventName) { + return isPresent(KeyEventsPlugin.parseEventName(eventName)); + }, + addEventListener: function(element, eventName, handler, shouldSupportBubble) { + var parsedEvent = KeyEventsPlugin.parseEventName(eventName); + var outsideHandler = KeyEventsPlugin.eventCallback(element, shouldSupportBubble, StringMapWrapper.get(parsedEvent, 'fullKey'), handler, this.manager.getZone()); + this.manager.getZone().runOutsideAngular((function() { + DOM.on(element, StringMapWrapper.get(parsedEvent, 'domEventName'), outsideHandler); + })); + } + }, { + parseEventName: function(eventName) { + eventName = eventName.toLowerCase(); + var parts = eventName.split('.'); + var domEventName = ListWrapper.removeAt(parts, 0); + if ((parts.length === 0) || !(StringWrapper.equals(domEventName, 'keydown') || StringWrapper.equals(domEventName, 'keyup'))) { + return null; + } + var key = ListWrapper.removeLast(parts); + var fullKey = ''; + ListWrapper.forEach(modifierKeys, (function(modifierName) { + if (ListWrapper.contains(parts, modifierName)) { + ListWrapper.remove(parts, modifierName); + fullKey += modifierName + '.'; + } + })); + fullKey += key; + if (parts.length != 0 || key.length === 0) { + return null; + } + return { + 'domEventName': domEventName, + 'fullKey': fullKey + }; + }, + getEventFullKey: function(event) { + var fullKey = ''; + var key = DOM.getEventKey(event); + key = key.toLowerCase(); + if (StringWrapper.equals(key, ' ')) { + key = 'space'; + } else if (StringWrapper.equals(key, '.')) { + key = 'dot'; + } + ListWrapper.forEach(modifierKeys, (function(modifierName) { + if (modifierName != key) { + var modifierGetter = StringMapWrapper.get(modifierKeyGetters, modifierName); + if (modifierGetter(event)) { + fullKey += modifierName + '.'; + } + } + })); + fullKey += key; + return fullKey; + }, + eventCallback: function(element, shouldSupportBubble, fullKey, handler, zone) { + return (function(event) { + var correctElement = shouldSupportBubble || event.target === element; + if (correctElement && KeyEventsPlugin.getEventFullKey(event) === fullKey) { + zone.run((function() { + return handler(event); + })); + } + }); + } + }, $__super); + }(EventManagerPlugin)); + $__export("KeyEventsPlugin", KeyEventsPlugin); + Object.defineProperty(KeyEventsPlugin.prototype.supports, "parameters", {get: function() { return [[assert.type.string]]; }}); - Object.defineProperty(ShadowCss.prototype._applySelectorScope, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(ShadowCss.prototype._applySimpleSelectorScope, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(ShadowCss.prototype._applyStrictSelectorScope, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; + Object.defineProperty(KeyEventsPlugin.prototype.addEventListener, "parameters", {get: function() { + return [[], [assert.type.string], [Function], [assert.type.boolean]]; }}); - Object.defineProperty(ShadowCss.prototype._insertPolyfillHostInCssText, "parameters", {get: function() { + Object.defineProperty(KeyEventsPlugin.parseEventName, "parameters", {get: function() { return [[assert.type.string]]; }}); - _cssContentNextSelectorRe = RegExpWrapper.create('polyfill-next-selector[^}]*content:[\\s]*?[\'"](.*?)[\'"][;\\s]*}([^{]*?){', 'im'); - _cssContentRuleRe = RegExpWrapper.create('(polyfill-rule)[^}]*(content:[\\s]*[\'"](.*?)[\'"])[;\\s]*[^}]*}', 'im'); - _cssContentUnscopedRuleRe = RegExpWrapper.create('(polyfill-unscoped-rule)[^}]*(content:[\\s]*[\'"](.*?)[\'"])[;\\s]*[^}]*}', 'im'); - _polyfillHost = '-shadowcsshost'; - _polyfillHostContext = '-shadowcsscontext'; - _parenSuffix = ')(?:\\((' + '(?:\\([^)(]*\\)|[^)(]*)+?' + ')\\))?([^,{]*)'; - _cssColonHostRe = RegExpWrapper.create('(' + _polyfillHost + _parenSuffix, 'im'); - _cssColonHostContextRe = RegExpWrapper.create('(' + _polyfillHostContext + _parenSuffix, 'im'); - _polyfillHostNoCombinator = _polyfillHost + '-no-combinator'; - _shadowDOMSelectorsRe = [RegExpWrapper.create('>>>'), RegExpWrapper.create('::shadow'), RegExpWrapper.create('::content'), RegExpWrapper.create('/deep/'), RegExpWrapper.create('/shadow-deep/'), RegExpWrapper.create('/shadow/')]; - _selectorReSuffix = '([>\\s~+\[.,{:][\\s\\S]*)?$'; - _polyfillHostRe = RegExpWrapper.create(_polyfillHost, 'im'); - _colonHostRe = RegExpWrapper.create(':host', 'im'); - _colonHostContextRe = RegExpWrapper.create(':host-context', 'im'); - Object.defineProperty(_cssToRules, "parameters", {get: function() { + } + }; +}); + +System.register("angular2/src/render/dom/events/hammer_common", ["angular2/src/render/dom/events/event_manager", "angular2/src/facade/collection"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/events/hammer_common"; + var EventManagerPlugin, + StringMapWrapper, + _eventNames, + HammerGesturesPluginCommon; + return { + setters: [function($__m) { + EventManagerPlugin = $__m.EventManagerPlugin; + }, function($__m) { + StringMapWrapper = $__m.StringMapWrapper; + }], + execute: function() { + _eventNames = { + 'pan': true, + 'panstart': true, + 'panmove': true, + 'panend': true, + 'pancancel': true, + 'panleft': true, + 'panright': true, + 'panup': true, + 'pandown': true, + 'pinch': true, + 'pinchstart': true, + 'pinchmove': true, + 'pinchend': true, + 'pinchcancel': true, + 'pinchin': true, + 'pinchout': true, + 'press': true, + 'pressup': true, + 'rotate': true, + 'rotatestart': true, + 'rotatemove': true, + 'rotateend': true, + 'rotatecancel': true, + 'swipe': true, + 'swipeleft': true, + 'swiperight': true, + 'swipeup': true, + 'swipedown': true, + 'tap': true + }; + HammerGesturesPluginCommon = (function($__super) { + function HammerGesturesPluginCommon() { + $traceurRuntime.superConstructor(HammerGesturesPluginCommon).call(this); + } + return ($traceurRuntime.createClass)(HammerGesturesPluginCommon, {supports: function(eventName) { + eventName = eventName.toLowerCase(); + return StringMapWrapper.contains(_eventNames, eventName); + }}, {}, $__super); + }(EventManagerPlugin)); + $__export("HammerGesturesPluginCommon", HammerGesturesPluginCommon); + Object.defineProperty(HammerGesturesPluginCommon.prototype.supports, "parameters", {get: function() { return [[assert.type.string]]; }}); - Object.defineProperty(_withCssRules, "parameters", {get: function() { - return [[assert.type.string], [Function]]; - }}); } }; }); -System.register("angular2/src/services/xhr_impl", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/async", "angular2/src/services/xhr"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/style_inliner", ["angular2/src/di/annotations_impl", "angular2/src/services/xhr", "angular2/src/facade/collection", "angular2/src/services/url_resolver", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/facade/lang", "angular2/src/facade/async"], function($__export) { "use strict"; - var __moduleName = "angular2/src/services/xhr_impl"; - var assert, - Injectable, + var __moduleName = "angular2/src/render/dom/shadow_dom/style_inliner"; + var Injectable, + XHR, + ListWrapper, + UrlResolver, + StyleUrlResolver, + isBlank, + isPresent, + RegExp, + RegExpWrapper, + StringWrapper, + normalizeBlank, Promise, PromiseWrapper, - XHR, - XHRImpl; + StyleInliner, + _importRe, + _urlRe, + _mediaQueryRe; + function _extractUrl(importRule) { + var match = RegExpWrapper.firstMatch(_urlRe, importRule); + if (isBlank(match)) + return null; + return isPresent(match[1]) ? match[1] : match[2]; + } + function _extractMediaQuery(importRule) { + var match = RegExpWrapper.firstMatch(_mediaQueryRe, importRule); + if (isBlank(match)) + return null; + var mediaQuery = match[1].trim(); + return (mediaQuery.length > 0) ? mediaQuery : null; + } + function _wrapInMediaRule(css, query) { + return (isBlank(query)) ? css : ("@media " + query + " {\n" + css + "\n}"); + } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injectable = $__m.Injectable; + }, function($__m) { + XHR = $__m.XHR; + }, function($__m) { + ListWrapper = $__m.ListWrapper; + }, function($__m) { + UrlResolver = $__m.UrlResolver; + }, function($__m) { + StyleUrlResolver = $__m.StyleUrlResolver; + }, function($__m) { + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + RegExp = $__m.RegExp; + RegExpWrapper = $__m.RegExpWrapper; + StringWrapper = $__m.StringWrapper; + normalizeBlank = $__m.normalizeBlank; }, function($__m) { Promise = $__m.Promise; PromiseWrapper = $__m.PromiseWrapper; - }, function($__m) { - XHR = $__m.XHR; }], execute: function() { - XHRImpl = (function($__super) { - function XHRImpl() { - $traceurRuntime.superConstructor(XHRImpl).apply(this, arguments); + StyleInliner = (function() { + function StyleInliner(xhr, styleUrlResolver, urlResolver) { + this._xhr = xhr; + this._urlResolver = urlResolver; + this._styleUrlResolver = styleUrlResolver; } - return ($traceurRuntime.createClass)(XHRImpl, {get: function(url) { - assert.argumentTypes(url, assert.type.string); - var completer = PromiseWrapper.completer(); - var xhr = new XMLHttpRequest(); - xhr.open('GET', url, true); - xhr.responseType = 'text'; - xhr.onload = function() { - var status = xhr.status; - if (200 <= status && status <= 300) { - completer.resolve(xhr.responseText); + return ($traceurRuntime.createClass)(StyleInliner, { + inlineImports: function(cssText, baseUrl) { + return this._inlineImports(cssText, baseUrl, []); + }, + _inlineImports: function(cssText, baseUrl, inlinedUrls) { + var $__0 = this; + var partIndex = 0; + var parts = StringWrapper.split(cssText, _importRe); + if (parts.length === 1) { + return cssText; + } + var promises = []; + while (partIndex < parts.length - 1) { + var prefix = parts[partIndex]; + var rule = parts[partIndex + 1]; + var url = _extractUrl(rule); + if (isPresent(url)) { + url = this._urlResolver.resolve(baseUrl, url); + } + var mediaQuery = _extractMediaQuery(rule); + var promise = void 0; + if (isBlank(url)) { + promise = PromiseWrapper.resolve(("/* Invalid import rule: \"@import "https://github.com/+%20rule%20+";\" */")); + } else if (ListWrapper.contains(inlinedUrls, url)) { + promise = PromiseWrapper.resolve(prefix); } else { - completer.reject(("Failed to load " + url)); + ListWrapper.push(inlinedUrls, url); + promise = PromiseWrapper.then(this._xhr.get(url), (function(css) { + css = $__0._inlineImports(css, url, inlinedUrls); + if (PromiseWrapper.isPromise(css)) { + return css.then((function(css) { + return prefix + $__0._transformImportedCss(css, mediaQuery, url) + '\n'; + })); + } else { + return prefix + $__0._transformImportedCss(css, mediaQuery, url) + '\n'; + } + }), (function(error) { + return ("/* failed to import " + url + " */\n"); + })); } - }; - xhr.onerror = function() { - completer.reject(("Failed to load " + url)); - }; - xhr.send(); - return assert.returnType((completer.promise), assert.genericType(Promise, assert.type.string)); - }}, {}, $__super); - }(XHR)); - $__export("XHRImpl", XHRImpl); - Object.defineProperty(XHRImpl, "annotations", {get: function() { + ListWrapper.push(promises, promise); + partIndex += 2; + } + return PromiseWrapper.all(promises).then(function(cssParts) { + var cssText = cssParts.join(''); + if (partIndex < parts.length) { + cssText += parts[partIndex]; + } + return cssText; + }); + }, + _transformImportedCss: function(css, mediaQuery, url) { + css = this._styleUrlResolver.resolveUrls(css, url); + return _wrapInMediaRule(css, mediaQuery); + } + }, {}); + }()); + $__export("StyleInliner", StyleInliner); + Object.defineProperty(StyleInliner, "annotations", {get: function() { return [new Injectable()]; }}); - Object.defineProperty(XHRImpl.prototype.get, "parameters", {get: function() { + Object.defineProperty(StyleInliner, "parameters", {get: function() { + return [[XHR], [StyleUrlResolver], [UrlResolver]]; + }}); + Object.defineProperty(StyleInliner.prototype.inlineImports, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(StyleInliner.prototype._inlineImports, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.genericType(List, assert.type.string)]]; + }}); + Object.defineProperty(StyleInliner.prototype._transformImportedCss, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(_extractUrl, "parameters", {get: function() { return [[assert.type.string]]; }}); + Object.defineProperty(_extractMediaQuery, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(_wrapInMediaRule, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string]]; + }}); + _importRe = RegExpWrapper.create('@import\\s+([^;]+);'); + _urlRe = RegExpWrapper.create('url\\(\\s*?[\'"]?([^\'")]+)[\'"]?|' + '[\'"]([^\'")]+)[\'"]'); + _mediaQueryRe = RegExpWrapper.create('[\'"][^\'"]+[\'"]\\s*\\)?\\s*(.*)'); } }; }); -System.register("angular2/src/render/dom/events/key_events", ["rtts_assert/rtts_assert", "angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/render/dom/events/event_manager"], function($__export) { +System.register("angular2/src/core/compiler/dynamic_component_loader", ["angular2/di", "angular2/src/di/annotations_impl", "angular2/src/core/compiler/compiler", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/element_ref"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/events/key_events"; - var assert, - DOM, - isPresent, - isBlank, - StringWrapper, - RegExpWrapper, + var __moduleName = "angular2/src/core/compiler/dynamic_component_loader"; + var Key, + Injector, + ResolvedBinding, + Binding, + bind, + Injectable, + Compiler, + Type, BaseException, - NumberWrapper, - StringMapWrapper, - ListWrapper, - EventManagerPlugin, - modifierKeys, - modifierKeyGetters, - KeyEventsPlugin; + stringify, + isPresent, + Promise, + AppViewManager, + ComponentCreateResult, + ElementRef, + ComponentRef, + DynamicComponentLoader; return { setters: [function($__m) { - assert = $__m.assert; + Key = $__m.Key; + Injector = $__m.Injector; + ResolvedBinding = $__m.ResolvedBinding; + Binding = $__m.Binding; + bind = $__m.bind; }, function($__m) { - DOM = $__m.DOM; + Injectable = $__m.Injectable; }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - StringWrapper = $__m.StringWrapper; - RegExpWrapper = $__m.RegExpWrapper; + Compiler = $__m.Compiler; + }, function($__m) { + Type = $__m.Type; BaseException = $__m.BaseException; - NumberWrapper = $__m.NumberWrapper; + stringify = $__m.stringify; + isPresent = $__m.isPresent; }, function($__m) { - StringMapWrapper = $__m.StringMapWrapper; - ListWrapper = $__m.ListWrapper; + Promise = $__m.Promise; }, function($__m) { - EventManagerPlugin = $__m.EventManagerPlugin; + AppViewManager = $__m.AppViewManager; + ComponentCreateResult = $__m.ComponentCreateResult; + }, function($__m) { + ElementRef = $__m.ElementRef; }], execute: function() { - modifierKeys = ['alt', 'control', 'meta', 'shift']; - modifierKeyGetters = { - 'alt': (function(event) { - return event.altKey; - }), - 'control': (function(event) { - return event.ctrlKey; - }), - 'meta': (function(event) { - return event.metaKey; - }), - 'shift': (function(event) { - return event.shiftKey; - }) - }; - KeyEventsPlugin = (function($__super) { - function KeyEventsPlugin() { - $traceurRuntime.superConstructor(KeyEventsPlugin).call(this); + ComponentRef = (function() { + function ComponentRef(location, instance, dispose) { + this.location = location; + this.instance = instance; + this._dispose = dispose; } - return ($traceurRuntime.createClass)(KeyEventsPlugin, { - supports: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); - return assert.returnType((isPresent(KeyEventsPlugin.parseEventName(eventName))), assert.type.boolean); + return ($traceurRuntime.createClass)(ComponentRef, { + get hostView() { + return this.location.parentView; }, - addEventListener: function(element, eventName, handler, shouldSupportBubble) { - assert.argumentTypes(element, assert.type.any, eventName, assert.type.string, handler, Function, shouldSupportBubble, assert.type.boolean); - var parsedEvent = KeyEventsPlugin.parseEventName(eventName); - var outsideHandler = KeyEventsPlugin.eventCallback(element, shouldSupportBubble, StringMapWrapper.get(parsedEvent, 'fullKey'), handler, this.manager.getZone()); - this.manager.getZone().runOutsideAngular((function() { - DOM.on(element, StringMapWrapper.get(parsedEvent, 'domEventName'), outsideHandler); - })); + dispose: function() { + this._dispose(); } - }, { - parseEventName: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); - eventName = eventName.toLowerCase(); - var parts = eventName.split('.'); - var domEventName = ListWrapper.removeAt(parts, 0); - if ((parts.length === 0) || !(StringWrapper.equals(domEventName, 'keydown') || StringWrapper.equals(domEventName, 'keyup'))) { - return null; - } - var key = ListWrapper.removeLast(parts); - var fullKey = ''; - ListWrapper.forEach(modifierKeys, (function(modifierName) { - if (ListWrapper.contains(parts, modifierName)) { - ListWrapper.remove(parts, modifierName); - fullKey += modifierName + '.'; - } + }, {}); + }()); + $__export("ComponentRef", ComponentRef); + Object.defineProperty(ComponentRef, "parameters", {get: function() { + return [[ElementRef], [assert.type.any], [Function]]; + }}); + DynamicComponentLoader = (function() { + function DynamicComponentLoader(compiler, viewManager) { + this._compiler = compiler; + this._viewManager = viewManager; + } + return ($traceurRuntime.createClass)(DynamicComponentLoader, { + loadIntoExistingLocation: function(typeOrBinding, location) { + var injector = arguments[2] !== (void 0) ? arguments[2] : null; + var $__0 = this; + var binding = this._getBinding(typeOrBinding); + return this._compiler.compile(binding.token).then((function(componentProtoViewRef) { + $__0._viewManager.createDynamicComponentView(location, componentProtoViewRef, binding, injector); + var component = $__0._viewManager.getComponent(location); + var dispose = (function() { + throw new BaseException("Not implemented"); + }); + return new ComponentRef(location, component, dispose); })); - fullKey += key; - if (parts.length != 0 || key.length === 0) { - return null; - } - return { - 'domEventName': domEventName, - 'fullKey': fullKey - }; }, - getEventFullKey: function(event) { - var fullKey = ''; - var key = DOM.getEventKey(event); - key = key.toLowerCase(); - if (StringWrapper.equals(key, ' ')) { - key = 'space'; - } else if (StringWrapper.equals(key, '.')) { - key = 'dot'; - } - ListWrapper.forEach(modifierKeys, (function(modifierName) { - if (modifierName != key) { - var modifierGetter = StringMapWrapper.get(modifierKeyGetters, modifierName); - if (modifierGetter(event)) { - fullKey += modifierName + '.'; - } - } + loadIntoNewLocation: function(typeOrBinding, parentComponentLocation, elementSelector) { + var injector = arguments[3] !== (void 0) ? arguments[3] : null; + var $__0 = this; + return this._compiler.compileInHost(this._getBinding(typeOrBinding)).then((function(hostProtoViewRef) { + var hostViewRef = $__0._viewManager.createInPlaceHostView(parentComponentLocation, elementSelector, hostProtoViewRef, injector); + var newLocation = new ElementRef(hostViewRef, 0); + var component = $__0._viewManager.getComponent(newLocation); + var dispose = (function() { + $__0._viewManager.destroyInPlaceHostView(parentComponentLocation, hostViewRef); + }); + return new ComponentRef(newLocation, component, dispose); })); - fullKey += key; - return assert.returnType((fullKey), assert.type.string); }, - eventCallback: function(element, shouldSupportBubble, fullKey, handler, zone) { - return (function(event) { - var correctElement = shouldSupportBubble || event.target === element; - if (correctElement && KeyEventsPlugin.getEventFullKey(event) === fullKey) { - zone.run((function() { - return handler(event); - })); - } - }); + loadNextToExistingLocation: function(typeOrBinding, location) { + var injector = arguments[2] !== (void 0) ? arguments[2] : null; + var $__0 = this; + var binding = this._getBinding(typeOrBinding); + return this._compiler.compileInHost(binding).then((function(hostProtoViewRef) { + var viewContainer = $__0._viewManager.getViewContainer(location); + var hostViewRef = viewContainer.create(hostProtoViewRef, viewContainer.length, null, injector); + var newLocation = new ElementRef(hostViewRef, 0); + var component = $__0._viewManager.getComponent(newLocation); + var dispose = (function() { + var index = viewContainer.indexOf(hostViewRef); + viewContainer.remove(index); + }); + return new ComponentRef(newLocation, component, dispose); + })); + }, + _getBinding: function(typeOrBinding) { + var binding; + if (typeOrBinding instanceof Binding) { + binding = typeOrBinding; + } else { + binding = bind(typeOrBinding).toClass(typeOrBinding); + } + return binding; } - }, $__super); - }(EventManagerPlugin)); - $__export("KeyEventsPlugin", KeyEventsPlugin); - Object.defineProperty(KeyEventsPlugin.prototype.supports, "parameters", {get: function() { - return [[assert.type.string]]; + }, {}); + }()); + $__export("DynamicComponentLoader", DynamicComponentLoader); + Object.defineProperty(DynamicComponentLoader, "annotations", {get: function() { + return [new Injectable()]; }}); - Object.defineProperty(KeyEventsPlugin.prototype.addEventListener, "parameters", {get: function() { - return [[], [assert.type.string], [Function], [assert.type.boolean]]; + Object.defineProperty(DynamicComponentLoader, "parameters", {get: function() { + return [[Compiler], [AppViewManager]]; }}); - Object.defineProperty(KeyEventsPlugin.parseEventName, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(DynamicComponentLoader.prototype.loadIntoExistingLocation, "parameters", {get: function() { + return [[], [ElementRef], [Injector]]; + }}); + Object.defineProperty(DynamicComponentLoader.prototype.loadIntoNewLocation, "parameters", {get: function() { + return [[], [ElementRef], [assert.type.string], [Injector]]; + }}); + Object.defineProperty(DynamicComponentLoader.prototype.loadNextToExistingLocation, "parameters", {get: function() { + return [[], [ElementRef], [Injector]]; }}); } }; }); -System.register("angular2/src/render/dom/events/hammer_common", ["rtts_assert/rtts_assert", "angular2/src/render/dom/events/event_manager", "angular2/src/facade/collection"], function($__export) { +System.register("angular2/src/core/testability/get_testability", ["angular2/src/core/testability/testability", "angular2/src/facade/lang"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/events/hammer_common"; - var assert, - EventManagerPlugin, - StringMapWrapper, - _eventNames, - HammerGesturesPluginCommon; + var __moduleName = "angular2/src/core/testability/get_testability"; + var TestabilityRegistry, + Testability, + global, + PublicTestability, + GetTestability; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - EventManagerPlugin = $__m.EventManagerPlugin; + TestabilityRegistry = $__m.TestabilityRegistry; + Testability = $__m.Testability; }, function($__m) { - StringMapWrapper = $__m.StringMapWrapper; + global = $__m.global; }], execute: function() { - _eventNames = { - 'pan': true, - 'panstart': true, - 'panmove': true, - 'panend': true, - 'pancancel': true, - 'panleft': true, - 'panright': true, - 'panup': true, - 'pandown': true, - 'pinch': true, - 'pinchstart': true, - 'pinchmove': true, - 'pinchend': true, - 'pinchcancel': true, - 'pinchin': true, - 'pinchout': true, - 'press': true, - 'pressup': true, - 'rotate': true, - 'rotatestart': true, - 'rotatemove': true, - 'rotateend': true, - 'rotatecancel': true, - 'swipe': true, - 'swipeleft': true, - 'swiperight': true, - 'swipeup': true, - 'swipedown': true, - 'tap': true - }; - HammerGesturesPluginCommon = (function($__super) { - function HammerGesturesPluginCommon() { - $traceurRuntime.superConstructor(HammerGesturesPluginCommon).call(this); + PublicTestability = (function() { + function PublicTestability(testability) { + this._testability = testability; } - return ($traceurRuntime.createClass)(HammerGesturesPluginCommon, {supports: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); - eventName = eventName.toLowerCase(); - return assert.returnType((StringMapWrapper.contains(_eventNames, eventName)), assert.type.boolean); - }}, {}, $__super); - }(EventManagerPlugin)); - $__export("HammerGesturesPluginCommon", HammerGesturesPluginCommon); - Object.defineProperty(HammerGesturesPluginCommon.prototype.supports, "parameters", {get: function() { - return [[assert.type.string]]; + return ($traceurRuntime.createClass)(PublicTestability, { + whenStable: function(callback) { + this._testability.whenStable(callback); + }, + findBindings: function(using, binding, exactMatch) { + return this._testability.findBindings(using, binding, exactMatch); + } + }, {}); + }()); + Object.defineProperty(PublicTestability, "parameters", {get: function() { + return [[Testability]]; + }}); + Object.defineProperty(PublicTestability.prototype.whenStable, "parameters", {get: function() { + return [[Function]]; + }}); + Object.defineProperty(PublicTestability.prototype.findBindings, "parameters", {get: function() { + return [[], [assert.type.string], [assert.type.boolean]]; + }}); + GetTestability = (function() { + function GetTestability() {} + return ($traceurRuntime.createClass)(GetTestability, {}, {addToWindow: function(registry) { + global.getAngularTestability = function(elem) { + var testability = registry.findTestabilityInTree(elem); + if (testability == null) { + throw new Error('Could not find testability for element.'); + } + return new PublicTestability(testability); + }; + }}); + }()); + $__export("GetTestability", GetTestability); + Object.defineProperty(GetTestability.addToWindow, "parameters", {get: function() { + return [[TestabilityRegistry]]; }}); } }; }); -System.register("angular2/src/render/dom/shadow_dom/style_inliner", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/services/xhr", "angular2/src/facade/collection", "angular2/src/services/url_resolver", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/facade/lang", "angular2/src/facade/async"], function($__export) { +System.register("angular2/src/render/dom/dom_renderer", ["angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/shadow_dom/content_tag", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/events/event_manager", "angular2/src/render/dom/view/proto_view", "angular2/src/render/dom/view/view", "angular2/src/render/dom/view/view_container", "angular2/src/render/dom/util", "angular2/src/render/api"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/style_inliner"; - var assert, - Injectable, - XHR, - ListWrapper, - UrlResolver, - StyleUrlResolver, - isBlank, - isPresent, - RegExp, - RegExpWrapper, - StringWrapper, - normalizeBlank, - Promise, - PromiseWrapper, - StyleInliner, - _importRe, - _urlRe, - _mediaQueryRe; - function _extractUrl(importRule) { - assert.argumentTypes(importRule, assert.type.string); - var match = RegExpWrapper.firstMatch(_urlRe, importRule); - if (isBlank(match)) - return assert.returnType((null), assert.type.string); - return assert.returnType((isPresent(match[1]) ? match[1] : match[2]), assert.type.string); - } - function _extractMediaQuery(importRule) { - assert.argumentTypes(importRule, assert.type.string); - var match = RegExpWrapper.firstMatch(_mediaQueryRe, importRule); - if (isBlank(match)) - return assert.returnType((null), assert.type.string); - var mediaQuery = match[1].trim(); - return assert.returnType(((mediaQuery.length > 0) ? mediaQuery : null), assert.type.string); - } - function _wrapInMediaRule(css, query) { - assert.argumentTypes(css, assert.type.string, query, assert.type.string); - return assert.returnType(((isBlank(query)) ? css : ("@media " + query + " {\n" + css + "\n}")), assert.type.string); - } + var __moduleName = "angular2/src/render/dom/dom_renderer"; + var Inject, + Injectable, + int, + isPresent, + isBlank, + BaseException, + RegExpWrapper, + ListWrapper, + MapWrapper, + Map, + StringMapWrapper, + List, + DOM, + Content, + ShadowDomStrategy, + EventManager, + DomProtoView, + DomProtoViewRef, + resolveInternalDomProtoView, + DomView, + DomViewRef, + resolveInternalDomView, + DomViewContainer, + NG_BINDING_CLASS_SELECTOR, + NG_BINDING_CLASS, + Renderer, + RenderProtoViewRef, + RenderViewRef, + DOCUMENT_TOKEN, + _DOCUMENT_SELECTOR_REGEX, + DomRenderer; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { + Inject = $__m.Inject; Injectable = $__m.Injectable; }, function($__m) { - XHR = $__m.XHR; + int = $__m.int; + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + BaseException = $__m.BaseException; + RegExpWrapper = $__m.RegExpWrapper; }, function($__m) { ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + Map = $__m.Map; + StringMapWrapper = $__m.StringMapWrapper; + List = $__m.List; }, function($__m) { - UrlResolver = $__m.UrlResolver; + DOM = $__m.DOM; }, function($__m) { - StyleUrlResolver = $__m.StyleUrlResolver; + Content = $__m.Content; }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - RegExp = $__m.RegExp; - RegExpWrapper = $__m.RegExpWrapper; - StringWrapper = $__m.StringWrapper; - normalizeBlank = $__m.normalizeBlank; + ShadowDomStrategy = $__m.ShadowDomStrategy; }, function($__m) { - Promise = $__m.Promise; - PromiseWrapper = $__m.PromiseWrapper; + EventManager = $__m.EventManager; + }, function($__m) { + DomProtoView = $__m.DomProtoView; + DomProtoViewRef = $__m.DomProtoViewRef; + resolveInternalDomProtoView = $__m.resolveInternalDomProtoView; + }, function($__m) { + DomView = $__m.DomView; + DomViewRef = $__m.DomViewRef; + resolveInternalDomView = $__m.resolveInternalDomView; + }, function($__m) { + DomViewContainer = $__m.DomViewContainer; + }, function($__m) { + NG_BINDING_CLASS_SELECTOR = $__m.NG_BINDING_CLASS_SELECTOR; + NG_BINDING_CLASS = $__m.NG_BINDING_CLASS; + }, function($__m) { + Renderer = $__m.Renderer; + RenderProtoViewRef = $__m.RenderProtoViewRef; + RenderViewRef = $__m.RenderViewRef; }], execute: function() { - StyleInliner = (function() { - function StyleInliner(xhr, styleUrlResolver, urlResolver) { - assert.argumentTypes(xhr, XHR, styleUrlResolver, StyleUrlResolver, urlResolver, UrlResolver); - this._xhr = xhr; - this._urlResolver = urlResolver; - this._styleUrlResolver = styleUrlResolver; - } - return ($traceurRuntime.createClass)(StyleInliner, { - inlineImports: function(cssText, baseUrl) { - assert.argumentTypes(cssText, assert.type.string, baseUrl, assert.type.string); - return this._inlineImports(cssText, baseUrl, []); + DOCUMENT_TOKEN = 'DocumentToken'; + $__export("DOCUMENT_TOKEN", DOCUMENT_TOKEN); + _DOCUMENT_SELECTOR_REGEX = RegExpWrapper.create('\\:document(.+)'); + DomRenderer = (function($__super) { + function DomRenderer(eventManager, shadowDomStrategy, document) { + $traceurRuntime.superConstructor(DomRenderer).call(this); + this._eventManager = eventManager; + this._shadowDomStrategy = shadowDomStrategy; + this._document = document; + } + return ($traceurRuntime.createClass)(DomRenderer, { + createInPlaceHostView: function(parentHostViewRef, hostElementSelector, hostProtoViewRef) { + var containerNode; + var documentSelectorMatch = RegExpWrapper.firstMatch(_DOCUMENT_SELECTOR_REGEX, hostElementSelector); + if (isPresent(documentSelectorMatch)) { + containerNode = this._document; + hostElementSelector = documentSelectorMatch[1]; + } else if (isPresent(parentHostViewRef)) { + var parentHostView = resolveInternalDomView(parentHostViewRef); + containerNode = parentHostView.shadowRoot; + } else { + containerNode = this._document; + } + var element = DOM.querySelector(containerNode, hostElementSelector); + if (isBlank(element)) { + throw new BaseException(("The selector \"" + hostElementSelector + "\" did not match any elements")); + } + var hostProtoView = resolveInternalDomProtoView(hostProtoViewRef); + return new DomViewRef(this._createView(hostProtoView, element)); }, - _inlineImports: function(cssText, baseUrl, inlinedUrls) { - var $__0 = this; - var partIndex = 0; - var parts = StringWrapper.split(cssText, _importRe); - if (parts.length === 1) { - return cssText; + destroyInPlaceHostView: function(parentHostViewRef, hostViewRef) { + var hostView = resolveInternalDomView(hostViewRef); + this._removeViewNodes(hostView); + }, + createView: function(protoViewRef) { + var protoView = resolveInternalDomProtoView(protoViewRef); + return new DomViewRef(this._createView(protoView, null)); + }, + destroyView: function(view) {}, + attachComponentView: function(hostViewRef, elementIndex, componentViewRef) { + var hostView = resolveInternalDomView(hostViewRef); + var componentView = resolveInternalDomView(componentViewRef); + var element = hostView.boundElements[elementIndex]; + var lightDom = hostView.lightDoms[elementIndex]; + if (isPresent(lightDom)) { + lightDom.attachShadowDomView(componentView); + } + var shadowRoot = this._shadowDomStrategy.prepareShadowRoot(element); + this._moveViewNodesIntoParent(shadowRoot, componentView); + componentView.hostLightDom = lightDom; + componentView.shadowRoot = shadowRoot; + }, + setComponentViewRootNodes: function(componentViewRef, rootNodes) { + var componentView = resolveInternalDomView(componentViewRef); + this._removeViewNodes(componentView); + componentView.rootNodes = rootNodes; + this._moveViewNodesIntoParent(componentView.shadowRoot, componentView); + }, + detachComponentView: function(hostViewRef, boundElementIndex, componentViewRef) { + var hostView = resolveInternalDomView(hostViewRef); + var componentView = resolveInternalDomView(componentViewRef); + this._removeViewNodes(componentView); + var lightDom = hostView.lightDoms[boundElementIndex]; + if (isPresent(lightDom)) { + lightDom.detachShadowDomView(); } - var promises = []; - while (partIndex < parts.length - 1) { - var prefix = parts[partIndex]; - var rule = parts[partIndex + 1]; - var url = _extractUrl(rule); - if (isPresent(url)) { - url = this._urlResolver.resolve(baseUrl, url); + componentView.hostLightDom = null; + componentView.shadowRoot = null; + }, + attachViewInContainer: function(parentViewRef, boundElementIndex, atIndex, viewRef) { + var parentView = resolveInternalDomView(parentViewRef); + var view = resolveInternalDomView(viewRef); + var viewContainer = this._getOrCreateViewContainer(parentView, boundElementIndex); + ListWrapper.insert(viewContainer.views, atIndex, view); + view.hostLightDom = parentView.hostLightDom; + var directParentLightDom = parentView.getDirectParentLightDom(boundElementIndex); + if (isBlank(directParentLightDom)) { + var siblingToInsertAfter; + if (atIndex == 0) { + siblingToInsertAfter = parentView.boundElements[boundElementIndex]; + } else { + siblingToInsertAfter = ListWrapper.last(viewContainer.views[atIndex - 1].rootNodes); } - var mediaQuery = _extractMediaQuery(rule); - var promise = void 0; - if (isBlank(url)) { - promise = PromiseWrapper.resolve(("/* Invalid import rule: \"@import "https://github.com/+%20rule%20+";\" */")); - } else if (ListWrapper.contains(inlinedUrls, url)) { - promise = PromiseWrapper.resolve(prefix); + this._moveViewNodesAfterSibling(siblingToInsertAfter, view); + } else { + directParentLightDom.redistribute(); + } + if (isPresent(parentView.hostLightDom)) { + parentView.hostLightDom.redistribute(); + } + }, + detachViewInContainer: function(parentViewRef, boundElementIndex, atIndex, viewRef) { + var parentView = resolveInternalDomView(parentViewRef); + var view = resolveInternalDomView(viewRef); + var viewContainer = parentView.viewContainers[boundElementIndex]; + var detachedView = viewContainer.views[atIndex]; + ListWrapper.removeAt(viewContainer.views, atIndex); + var directParentLightDom = parentView.getDirectParentLightDom(boundElementIndex); + if (isBlank(directParentLightDom)) { + this._removeViewNodes(detachedView); + } else { + directParentLightDom.redistribute(); + } + view.hostLightDom = null; + if (isPresent(parentView.hostLightDom)) { + parentView.hostLightDom.redistribute(); + } + }, + hydrateView: function(viewRef) { + var view = resolveInternalDomView(viewRef); + if (view.hydrated) + throw new BaseException('The view is already hydrated.'); + view.hydrated = true; + for (var i = 0; i < view.lightDoms.length; ++i) { + var lightDom = view.lightDoms[i]; + if (isPresent(lightDom)) { + lightDom.redistribute(); + } + } + view.eventHandlerRemovers = ListWrapper.create(); + var binders = view.proto.elementBinders; + for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { + var binder = binders[binderIdx]; + if (isPresent(binder.globalEvents)) { + for (var i = 0; i < binder.globalEvents.length; i++) { + var globalEvent = binder.globalEvents[i]; + var remover = this._createGlobalEventListener(view, binderIdx, globalEvent.name, globalEvent.target, globalEvent.fullName); + ListWrapper.push(view.eventHandlerRemovers, remover); + } + } + } + if (isPresent(view.hostLightDom)) { + view.hostLightDom.redistribute(); + } + }, + dehydrateView: function(viewRef) { + var view = resolveInternalDomView(viewRef); + for (var i = 0; i < view.eventHandlerRemovers.length; i++) { + view.eventHandlerRemovers[i](); + } + view.eventHandlerRemovers = null; + view.hydrated = false; + }, + setElementProperty: function(viewRef, elementIndex, propertyName, propertyValue) { + var view = resolveInternalDomView(viewRef); + view.setElementProperty(elementIndex, propertyName, propertyValue); + }, + callAction: function(viewRef, elementIndex, actionExpression, actionArgs) { + var view = resolveInternalDomView(viewRef); + view.callAction(elementIndex, actionExpression, actionArgs); + }, + setText: function(viewRef, textNodeIndex, text) { + var view = resolveInternalDomView(viewRef); + DOM.setText(view.boundTextNodes[textNodeIndex], text); + }, + setEventDispatcher: function(viewRef, dispatcher) { + var view = resolveInternalDomView(viewRef); + view.eventDispatcher = dispatcher; + }, + _createView: function(protoView, inplaceElement) { + var rootElementClone = isPresent(inplaceElement) ? inplaceElement : DOM.importIntoDoc(protoView.element); + var elementsWithBindingsDynamic; + if (protoView.isTemplateElement) { + elementsWithBindingsDynamic = DOM.querySelectorAll(DOM.content(rootElementClone), NG_BINDING_CLASS_SELECTOR); + } else { + elementsWithBindingsDynamic = DOM.getElementsByClassName(rootElementClone, NG_BINDING_CLASS); + } + var elementsWithBindings = ListWrapper.createFixedSize(elementsWithBindingsDynamic.length); + for (var binderIdx = 0; binderIdx < elementsWithBindingsDynamic.length; ++binderIdx) { + elementsWithBindings[binderIdx] = elementsWithBindingsDynamic[binderIdx]; + } + var viewRootNodes; + if (protoView.isTemplateElement) { + var childNode = DOM.firstChild(DOM.content(rootElementClone)); + viewRootNodes = []; + while (childNode != null) { + ListWrapper.push(viewRootNodes, childNode); + childNode = DOM.nextSibling(childNode); + } + } else { + viewRootNodes = [rootElementClone]; + } + var binders = protoView.elementBinders; + var boundTextNodes = []; + var boundElements = ListWrapper.createFixedSize(binders.length); + var contentTags = ListWrapper.createFixedSize(binders.length); + for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { + var binder = binders[binderIdx]; + var element = void 0; + if (binderIdx === 0 && protoView.rootBindingOffset === 1) { + element = rootElementClone; } else { - ListWrapper.push(inlinedUrls, url); - promise = PromiseWrapper.then(this._xhr.get(url), (function(css) { - css = $__0._inlineImports(css, url, inlinedUrls); - if (PromiseWrapper.isPromise(css)) { - return css.then((function(css) { - return prefix + $__0._transformImportedCss(css, mediaQuery, url) + '\n'; - })); - } else { - return prefix + $__0._transformImportedCss(css, mediaQuery, url) + '\n'; - } - }), (function(error) { - return ("/* failed to import " + url + " */\n"); - })); + element = elementsWithBindings[binderIdx - protoView.rootBindingOffset]; } - ListWrapper.push(promises, promise); - partIndex += 2; + boundElements[binderIdx] = element; + var childNodes = DOM.childNodes(DOM.templateAwareRoot(element)); + var textNodeIndices = binder.textNodeIndices; + for (var i = 0; i < textNodeIndices.length; i++) { + ListWrapper.push(boundTextNodes, childNodes[textNodeIndices[i]]); + } + var contentTag = null; + if (isPresent(binder.contentTagSelector)) { + contentTag = new Content(element, binder.contentTagSelector); + } + contentTags[binderIdx] = contentTag; } - return PromiseWrapper.all(promises).then(function(cssParts) { - var cssText = cssParts.join(''); - if (partIndex < parts.length) { - cssText += parts[partIndex]; + var view = new DomView(protoView, viewRootNodes, boundTextNodes, boundElements, contentTags); + for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { + var binder = binders[binderIdx]; + var element = boundElements[binderIdx]; + var lightDom = null; + if (isPresent(binder.componentId)) { + lightDom = this._shadowDomStrategy.constructLightDom(view, boundElements[binderIdx]); } - return cssText; - }); + view.lightDoms[binderIdx] = lightDom; + var contentTag = contentTags[binderIdx]; + if (isPresent(contentTag)) { + var destLightDom = view.getDirectParentLightDom(binderIdx); + contentTag.init(destLightDom); + } + if (isPresent(binder.eventLocals) && isPresent(binder.localEvents)) { + for (var i = 0; i < binder.localEvents.length; i++) { + this._createEventListener(view, element, binderIdx, binder.localEvents[i].name, binder.eventLocals); + } + } + } + return view; }, - _transformImportedCss: function(css, mediaQuery, url) { - assert.argumentTypes(css, assert.type.string, mediaQuery, assert.type.string, url, assert.type.string); - css = this._styleUrlResolver.resolveUrls(css, url); - return assert.returnType((_wrapInMediaRule(css, mediaQuery)), assert.type.string); + _createEventListener: function(view, element, elementIndex, eventName, eventLocals) { + this._eventManager.addEventListener(element, eventName, (function(event) { + view.dispatchEvent(elementIndex, eventName, event); + })); + }, + _moveViewNodesAfterSibling: function(sibling, view) { + for (var i = view.rootNodes.length - 1; i >= 0; --i) { + DOM.insertAfter(sibling, view.rootNodes[i]); + } + }, + _moveViewNodesIntoParent: function(parent, view) { + for (var i = 0; i < view.rootNodes.length; ++i) { + DOM.appendChild(parent, view.rootNodes[i]); + } + }, + _removeViewNodes: function(view) { + var len = view.rootNodes.length; + if (len == 0) + return ; + var parent = view.rootNodes[0].parentNode; + for (var i = len - 1; i >= 0; --i) { + DOM.removeChild(parent, view.rootNodes[i]); + } + }, + _getOrCreateViewContainer: function(parentView, boundElementIndex) { + var vc = parentView.viewContainers[boundElementIndex]; + if (isBlank(vc)) { + vc = new DomViewContainer(); + parentView.viewContainers[boundElementIndex] = vc; + } + return vc; + }, + _createGlobalEventListener: function(view, elementIndex, eventName, eventTarget, fullName) { + return this._eventManager.addGlobalEventListener(eventTarget, eventName, (function(event) { + view.dispatchEvent(elementIndex, fullName, event); + })); } - }, {}); - }()); - $__export("StyleInliner", StyleInliner); - Object.defineProperty(StyleInliner, "annotations", {get: function() { + }, {}, $__super); + }(Renderer)); + $__export("DomRenderer", DomRenderer); + Object.defineProperty(DomRenderer, "annotations", {get: function() { return [new Injectable()]; }}); - Object.defineProperty(StyleInliner, "parameters", {get: function() { - return [[XHR], [StyleUrlResolver], [UrlResolver]]; + Object.defineProperty(DomRenderer, "parameters", {get: function() { + return [[EventManager], [ShadowDomStrategy], [new Inject(DOCUMENT_TOKEN)]]; + }}); + Object.defineProperty(DomRenderer.prototype.createInPlaceHostView, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.string], [RenderProtoViewRef]]; + }}); + Object.defineProperty(DomRenderer.prototype.destroyInPlaceHostView, "parameters", {get: function() { + return [[RenderViewRef], [RenderViewRef]]; }}); - Object.defineProperty(StyleInliner.prototype.inlineImports, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; + Object.defineProperty(DomRenderer.prototype.createView, "parameters", {get: function() { + return [[RenderProtoViewRef]]; }}); - Object.defineProperty(StyleInliner.prototype._inlineImports, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.genericType(List, assert.type.string)]]; + Object.defineProperty(DomRenderer.prototype.destroyView, "parameters", {get: function() { + return [[RenderViewRef]]; }}); - Object.defineProperty(StyleInliner.prototype._transformImportedCss, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [assert.type.string]]; + Object.defineProperty(DomRenderer.prototype.attachComponentView, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [RenderViewRef]]; }}); - Object.defineProperty(_extractUrl, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(DomRenderer.prototype.setComponentViewRootNodes, "parameters", {get: function() { + return [[RenderViewRef], [List]]; }}); - Object.defineProperty(_extractMediaQuery, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(DomRenderer.prototype.detachComponentView, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [RenderViewRef]]; }}); - Object.defineProperty(_wrapInMediaRule, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; + Object.defineProperty(DomRenderer.prototype.attachViewInContainer, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.number], [RenderViewRef]]; + }}); + Object.defineProperty(DomRenderer.prototype.detachViewInContainer, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.number], [RenderViewRef]]; + }}); + Object.defineProperty(DomRenderer.prototype.hydrateView, "parameters", {get: function() { + return [[RenderViewRef]]; + }}); + Object.defineProperty(DomRenderer.prototype.dehydrateView, "parameters", {get: function() { + return [[RenderViewRef]]; + }}); + Object.defineProperty(DomRenderer.prototype.setElementProperty, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.string], [assert.type.any]]; + }}); + Object.defineProperty(DomRenderer.prototype.callAction, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.string], [assert.type.any]]; + }}); + Object.defineProperty(DomRenderer.prototype.setText, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.number], [assert.type.string]]; + }}); + Object.defineProperty(DomRenderer.prototype.setEventDispatcher, "parameters", {get: function() { + return [[RenderViewRef], [assert.type.any]]; + }}); + Object.defineProperty(DomRenderer.prototype._createView, "parameters", {get: function() { + return [[DomProtoView], []]; + }}); + Object.defineProperty(DomRenderer.prototype._getOrCreateViewContainer, "parameters", {get: function() { + return [[DomView], []]; }}); - _importRe = RegExpWrapper.create('@import\\s+([^;]+);'); - _urlRe = RegExpWrapper.create('url\\(\\s*?[\'"]?([^\'")]+)[\'"]?|' + '[\'"]([^\'")]+)[\'"]'); - _mediaQueryRe = RegExpWrapper.create('[\'"][^\'"]+[\'"]\\s*\\)?\\s*(.*)'); } }; }); -System.register("angular2/src/core/compiler/dynamic_component_loader", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/core/compiler/compiler", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/element_ref"], function($__export) { +System.register("angular2/src/render/dom/view/property_setter_factory", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/util", "angular2/src/reflection/reflection"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/compiler/dynamic_component_loader"; - var assert, - Key, - Injector, - Injectable, - ResolvedBinding, - Binding, - bind, - Compiler, - Type, + var __moduleName = "angular2/src/render/dom/view/property_setter_factory"; + var StringWrapper, + RegExpWrapper, BaseException, - stringify, isPresent, - Promise, - AppViewManager, - ComponentCreateResult, - ElementRef, - ComponentRef, - DynamicComponentLoader; + isBlank, + isString, + stringify, + ListWrapper, + StringMapWrapper, + DOM, + camelCaseToDashCase, + dashCaseToCamelCase, + reflector, + STYLE_SEPARATOR, + propertySettersCache, + innerHTMLSetterCache, + ATTRIBUTE_PREFIX, + attributeSettersCache, + CLASS_PREFIX, + classSettersCache, + STYLE_PREFIX, + styleSettersCache; + function setterFactory(property) { + var setterFn, + styleParts, + styleSuffix; + if (StringWrapper.startsWith(property, ATTRIBUTE_PREFIX)) { + setterFn = attributeSetterFactory(StringWrapper.substring(property, ATTRIBUTE_PREFIX.length)); + } else if (StringWrapper.startsWith(property, CLASS_PREFIX)) { + setterFn = classSetterFactory(StringWrapper.substring(property, CLASS_PREFIX.length)); + } else if (StringWrapper.startsWith(property, STYLE_PREFIX)) { + styleParts = property.split(STYLE_SEPARATOR); + styleSuffix = styleParts.length > 2 ? ListWrapper.get(styleParts, 2) : ''; + setterFn = styleSetterFactory(ListWrapper.get(styleParts, 1), styleSuffix); + } else if (StringWrapper.equals(property, 'innerHtml')) { + if (isBlank(innerHTMLSetterCache)) { + innerHTMLSetterCache = (function(el, value) { + return DOM.setInnerHTML(el, value); + }); + } + setterFn = innerHTMLSetterCache; + } else { + property = resolvePropertyName(property); + setterFn = StringMapWrapper.get(propertySettersCache, property); + if (isBlank(setterFn)) { + var propertySetterFn = reflector.setter(property); + setterFn = function(receiver, value) { + if (DOM.hasProperty(receiver, property)) { + return propertySetterFn(receiver, value); + } + }; + StringMapWrapper.set(propertySettersCache, property, setterFn); + } + } + return setterFn; + } + function _isValidAttributeValue(attrName, value) { + if (attrName == "role") { + return isString(value); + } else { + return isPresent(value); + } + } + function attributeSetterFactory(attrName) { + var setterFn = StringMapWrapper.get(attributeSettersCache, attrName); + var dashCasedAttributeName; + if (isBlank(setterFn)) { + dashCasedAttributeName = camelCaseToDashCase(attrName); + setterFn = function(element, value) { + if (_isValidAttributeValue(dashCasedAttributeName, value)) { + DOM.setAttribute(element, dashCasedAttributeName, stringify(value)); + } else { + if (isPresent(value)) { + throw new BaseException("Invalid " + dashCasedAttributeName + " attribute, only string values are allowed, got '" + stringify(value) + "'"); + } + DOM.removeAttribute(element, dashCasedAttributeName); + } + }; + StringMapWrapper.set(attributeSettersCache, attrName, setterFn); + } + return setterFn; + } + function classSetterFactory(className) { + var setterFn = StringMapWrapper.get(classSettersCache, className); + var dashCasedClassName; + if (isBlank(setterFn)) { + dashCasedClassName = camelCaseToDashCase(className); + setterFn = function(element, value) { + if (value) { + DOM.addClass(element, dashCasedClassName); + } else { + DOM.removeClass(element, dashCasedClassName); + } + }; + StringMapWrapper.set(classSettersCache, className, setterFn); + } + return setterFn; + } + function styleSetterFactory(styleName, styleSuffix) { + var cacheKey = styleName + styleSuffix; + var setterFn = StringMapWrapper.get(styleSettersCache, cacheKey); + var dashCasedStyleName; + if (isBlank(setterFn)) { + dashCasedStyleName = camelCaseToDashCase(styleName); + setterFn = function(element, value) { + var valAsStr; + if (isPresent(value)) { + valAsStr = stringify(value); + DOM.setStyle(element, dashCasedStyleName, valAsStr + styleSuffix); + } else { + DOM.removeStyle(element, dashCasedStyleName); + } + }; + StringMapWrapper.set(styleSettersCache, cacheKey, setterFn); + } + return setterFn; + } + function resolvePropertyName(attrName) { + var mappedPropName = StringMapWrapper.get(DOM.attrToPropMap, attrName); + return isPresent(mappedPropName) ? mappedPropName : attrName; + } + $__export("setterFactory", setterFactory); return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Key = $__m.Key; - Injector = $__m.Injector; - Injectable = $__m.Injectable; - ResolvedBinding = $__m.ResolvedBinding; - Binding = $__m.Binding; - bind = $__m.bind; - }, function($__m) { - Compiler = $__m.Compiler; - }, function($__m) { - Type = $__m.Type; + StringWrapper = $__m.StringWrapper; + RegExpWrapper = $__m.RegExpWrapper; BaseException = $__m.BaseException; - stringify = $__m.stringify; isPresent = $__m.isPresent; - }, function($__m) { - Promise = $__m.Promise; - }, function($__m) { - AppViewManager = $__m.AppViewManager; - ComponentCreateResult = $__m.ComponentCreateResult; - }, function($__m) { - ElementRef = $__m.ElementRef; - }], - execute: function() { - ComponentRef = (function() { - function ComponentRef(location, instance, dispose) { - assert.argumentTypes(location, ElementRef, instance, assert.type.any, dispose, Function); - this.location = location; - this.instance = instance; - this._dispose = dispose; - } - return ($traceurRuntime.createClass)(ComponentRef, { - get hostView() { - return this.location.parentView; - }, - dispose: function() { - this._dispose(); - } - }, {}); - }()); - $__export("ComponentRef", ComponentRef); - Object.defineProperty(ComponentRef, "parameters", {get: function() { - return [[ElementRef], [assert.type.any], [Function]]; - }}); - DynamicComponentLoader = (function() { - function DynamicComponentLoader(compiler, viewManager) { - assert.argumentTypes(compiler, Compiler, viewManager, AppViewManager); - this._compiler = compiler; - this._viewManager = viewManager; - } - return ($traceurRuntime.createClass)(DynamicComponentLoader, { - loadIntoExistingLocation: function(typeOrBinding, location) { - var injector = arguments[2] !== (void 0) ? arguments[2] : null; - var $__0 = this; - assert.argumentTypes(typeOrBinding, assert.type.any, location, ElementRef, injector, Injector); - var binding = this._getBinding(typeOrBinding); - return assert.returnType((this._compiler.compile(binding.token).then((function(componentProtoViewRef) { - $__0._viewManager.createDynamicComponentView(location, componentProtoViewRef, binding, injector); - var component = $__0._viewManager.getComponent(location); - var dispose = (function() { - throw new BaseException("Not implemented"); - }); - return new ComponentRef(location, component, dispose); - }))), assert.genericType(Promise, ComponentRef)); - }, - loadIntoNewLocation: function(typeOrBinding, parentComponentLocation, elementOrSelector) { - var injector = arguments[3] !== (void 0) ? arguments[3] : null; - var $__0 = this; - assert.argumentTypes(typeOrBinding, assert.type.any, parentComponentLocation, ElementRef, elementOrSelector, assert.type.any, injector, Injector); - return assert.returnType((this._compiler.compileInHost(this._getBinding(typeOrBinding)).then((function(hostProtoViewRef) { - var hostViewRef = $__0._viewManager.createInPlaceHostView(parentComponentLocation, elementOrSelector, hostProtoViewRef, injector); - var newLocation = new ElementRef(hostViewRef, 0); - var component = $__0._viewManager.getComponent(newLocation); - var dispose = (function() { - $__0._viewManager.destroyInPlaceHostView(parentComponentLocation, hostViewRef); - }); - return new ComponentRef(newLocation, component, dispose); - }))), assert.genericType(Promise, ComponentRef)); - }, - loadNextToExistingLocation: function(typeOrBinding, location) { - var injector = arguments[2] !== (void 0) ? arguments[2] : null; - var $__0 = this; - assert.argumentTypes(typeOrBinding, assert.type.any, location, ElementRef, injector, Injector); - var binding = this._getBinding(typeOrBinding); - return assert.returnType((this._compiler.compileInHost(binding).then((function(hostProtoViewRef) { - var viewContainer = $__0._viewManager.getViewContainer(location); - var hostViewRef = viewContainer.create(hostProtoViewRef, viewContainer.length, injector); - var newLocation = new ElementRef(hostViewRef, 0); - var component = $__0._viewManager.getComponent(newLocation); - var dispose = (function() { - var index = viewContainer.indexOf(hostViewRef); - viewContainer.remove(index); - }); - return new ComponentRef(newLocation, component, dispose); - }))), assert.genericType(Promise, ComponentRef)); - }, - _getBinding: function(typeOrBinding) { - var binding; - if (typeOrBinding instanceof Binding) { - binding = typeOrBinding; - } else { - binding = bind(typeOrBinding).toClass(typeOrBinding); - } - return binding; - } - }, {}); - }()); - $__export("DynamicComponentLoader", DynamicComponentLoader); - Object.defineProperty(DynamicComponentLoader, "annotations", {get: function() { - return [new Injectable()]; + isBlank = $__m.isBlank; + isString = $__m.isString; + stringify = $__m.stringify; + }, function($__m) { + ListWrapper = $__m.ListWrapper; + StringMapWrapper = $__m.StringMapWrapper; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + camelCaseToDashCase = $__m.camelCaseToDashCase; + dashCaseToCamelCase = $__m.dashCaseToCamelCase; + }, function($__m) { + reflector = $__m.reflector; + }], + execute: function() { + STYLE_SEPARATOR = '.'; + propertySettersCache = StringMapWrapper.create(); + Object.defineProperty(setterFactory, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(DynamicComponentLoader, "parameters", {get: function() { - return [[Compiler], [AppViewManager]]; + ATTRIBUTE_PREFIX = 'attr.'; + attributeSettersCache = StringMapWrapper.create(); + Object.defineProperty(_isValidAttributeValue, "parameters", {get: function() { + return [[assert.type.string], [assert.type.any]]; }}); - Object.defineProperty(DynamicComponentLoader.prototype.loadIntoExistingLocation, "parameters", {get: function() { - return [[], [ElementRef], [Injector]]; + Object.defineProperty(attributeSetterFactory, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(DynamicComponentLoader.prototype.loadIntoNewLocation, "parameters", {get: function() { - return [[], [ElementRef], [assert.type.any], [Injector]]; + CLASS_PREFIX = 'class.'; + classSettersCache = StringMapWrapper.create(); + Object.defineProperty(classSetterFactory, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(DynamicComponentLoader.prototype.loadNextToExistingLocation, "parameters", {get: function() { - return [[], [ElementRef], [Injector]]; + STYLE_PREFIX = 'style.'; + styleSettersCache = StringMapWrapper.create(); + Object.defineProperty(styleSetterFactory, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(resolvePropertyName, "parameters", {get: function() { + return [[assert.type.string]]; }}); } }; }); -System.register("angular2/src/core/testability/get_testability", ["rtts_assert/rtts_assert", "angular2/src/core/testability/testability", "angular2/src/facade/lang"], function($__export) { +System.register("angular2/src/render/dom/compiler/compile_step", ["angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/testability/get_testability"; - var assert, - TestabilityRegistry, - Testability, - global, - PublicTestability, - GetTestability; + var __moduleName = "angular2/src/render/dom/compiler/compile_step"; + var CompileElement, + compileControlModule, + CompileStep; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - TestabilityRegistry = $__m.TestabilityRegistry; - Testability = $__m.Testability; + CompileElement = $__m.CompileElement; }, function($__m) { - global = $__m.global; + compileControlModule = $__m; }], execute: function() { - PublicTestability = (function() { - function PublicTestability(testability) { - assert.argumentTypes(testability, Testability); - this._testability = testability; - } - return ($traceurRuntime.createClass)(PublicTestability, { - whenStable: function(callback) { - assert.argumentTypes(callback, Function); - this._testability.whenStable(callback); - }, - findBindings: function(using, binding, exactMatch) { - assert.argumentTypes(using, assert.type.any, binding, assert.type.string, exactMatch, assert.type.boolean); - return this._testability.findBindings(using, binding, exactMatch); - } - }, {}); - }()); - Object.defineProperty(PublicTestability, "parameters", {get: function() { - return [[Testability]]; - }}); - Object.defineProperty(PublicTestability.prototype.whenStable, "parameters", {get: function() { - return [[Function]]; - }}); - Object.defineProperty(PublicTestability.prototype.findBindings, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.boolean]]; - }}); - GetTestability = (function() { - function GetTestability() {} - return ($traceurRuntime.createClass)(GetTestability, {}, {addToWindow: function(registry) { - assert.argumentTypes(registry, TestabilityRegistry); - global.getAngularTestability = function(elem) { - var testability = registry.findTestabilityInTree(elem); - if (testability == null) { - throw new Error('Could not find testability for element.'); - } - return assert.returnType((new PublicTestability(testability)), PublicTestability); - }; - }}); + CompileStep = (function() { + function CompileStep() {} + return ($traceurRuntime.createClass)(CompileStep, {process: function(parent, current, control) {}}, {}); }()); - $__export("GetTestability", GetTestability); - Object.defineProperty(GetTestability.addToWindow, "parameters", {get: function() { - return [[TestabilityRegistry]]; + $__export("CompileStep", CompileStep); + Object.defineProperty(CompileStep.prototype.process, "parameters", {get: function() { + return [[CompileElement], [CompileElement], [compileControlModule.CompileControl]]; }}); } }; }); -System.register("angular2/src/core/application_tokens", ["rtts_assert/rtts_assert", "angular2/di"], function($__export) { +System.register("angular2/src/render/dom/compiler/property_binding_parser", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/change_detection", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/dom/util"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/application_tokens"; - var assert, - OpaqueToken, - appComponentRefToken, - appElementToken, - appComponentAnnotatedTypeToken, - appDocumentToken; + var __moduleName = "angular2/src/render/dom/compiler/property_binding_parser"; + var isPresent, + RegExpWrapper, + MapWrapper, + Parser, + CompileStep, + CompileElement, + CompileControl, + dashCaseToCamelCase, + BIND_NAME_REGEXP, + PropertyBindingParser; return { setters: [function($__m) { - assert = $__m.assert; + isPresent = $__m.isPresent; + RegExpWrapper = $__m.RegExpWrapper; }, function($__m) { - OpaqueToken = $__m.OpaqueToken; + MapWrapper = $__m.MapWrapper; + }, function($__m) { + Parser = $__m.Parser; + }, function($__m) { + CompileStep = $__m.CompileStep; + }, function($__m) { + CompileElement = $__m.CompileElement; + }, function($__m) { + CompileControl = $__m.CompileControl; + }, function($__m) { + dashCaseToCamelCase = $__m.dashCaseToCamelCase; }], execute: function() { - appComponentRefToken = assert.type(new OpaqueToken('ComponentRef'), OpaqueToken); - $__export("appComponentRefToken", appComponentRefToken); - appElementToken = assert.type(new OpaqueToken('AppElement'), OpaqueToken); - $__export("appElementToken", appElementToken); - appComponentAnnotatedTypeToken = assert.type(new OpaqueToken('AppComponentAnnotatedType'), OpaqueToken); - $__export("appComponentAnnotatedTypeToken", appComponentAnnotatedTypeToken); - appDocumentToken = assert.type(new OpaqueToken('AppDocument'), OpaqueToken); - $__export("appDocumentToken", appDocumentToken); + BIND_NAME_REGEXP = RegExpWrapper.create('^(?:(?:(?:(bind-)|(var-|#)|(on-))(.+))|\\[([^\\]]+)\\]|\\(([^\\)]+)\\))$'); + PropertyBindingParser = (function($__super) { + function PropertyBindingParser(parser) { + $traceurRuntime.superConstructor(PropertyBindingParser).call(this); + this._parser = parser; + } + return ($traceurRuntime.createClass)(PropertyBindingParser, { + process: function(parent, current, control) { + var $__0 = this; + var attrs = current.attrs(); + var newAttrs = MapWrapper.create(); + MapWrapper.forEach(attrs, (function(attrValue, attrName) { + var bindParts = RegExpWrapper.firstMatch(BIND_NAME_REGEXP, attrName); + if (isPresent(bindParts)) { + if (isPresent(bindParts[1])) { + $__0._bindProperty(bindParts[4], attrValue, current, newAttrs); + } else if (isPresent(bindParts[2])) { + var identifier = bindParts[4]; + var value = attrValue == '' ? '\$implicit' : attrValue; + $__0._bindVariable(identifier, value, current, newAttrs); + } else if (isPresent(bindParts[3])) { + $__0._bindEvent(bindParts[4], attrValue, current, newAttrs); + } else if (isPresent(bindParts[5])) { + $__0._bindProperty(bindParts[5], attrValue, current, newAttrs); + } else if (isPresent(bindParts[6])) { + $__0._bindEvent(bindParts[6], attrValue, current, newAttrs); + } + } else { + var expr = $__0._parser.parseInterpolation(attrValue, current.elementDescription); + if (isPresent(expr)) { + $__0._bindPropertyAst(attrName, expr, current, newAttrs); + } + } + })); + MapWrapper.forEach(newAttrs, (function(attrValue, attrName) { + MapWrapper.set(attrs, attrName, attrValue); + })); + }, + _bindVariable: function(identifier, value, current, newAttrs) { + current.bindElement().bindVariable(dashCaseToCamelCase(identifier), value); + MapWrapper.set(newAttrs, identifier, value); + }, + _bindProperty: function(name, expression, current, newAttrs) { + this._bindPropertyAst(name, this._parser.parseBinding(expression, current.elementDescription), current, newAttrs); + }, + _bindPropertyAst: function(name, ast, current, newAttrs) { + var binder = current.bindElement(); + var camelCaseName = dashCaseToCamelCase(name); + binder.bindProperty(camelCaseName, ast); + MapWrapper.set(newAttrs, name, ast.source); + }, + _bindEvent: function(name, expression, current, newAttrs) { + current.bindElement().bindEvent(dashCaseToCamelCase(name), this._parser.parseAction(expression, current.elementDescription)); + } + }, {}, $__super); + }(CompileStep)); + $__export("PropertyBindingParser", PropertyBindingParser); + Object.defineProperty(PropertyBindingParser, "parameters", {get: function() { + return [[Parser]]; + }}); + Object.defineProperty(PropertyBindingParser.prototype.process, "parameters", {get: function() { + return [[CompileElement], [CompileElement], [CompileControl]]; + }}); + Object.defineProperty(PropertyBindingParser.prototype._bindVariable, "parameters", {get: function() { + return [[], [], [CompileElement], []]; + }}); + Object.defineProperty(PropertyBindingParser.prototype._bindProperty, "parameters", {get: function() { + return [[], [], [CompileElement], []]; + }}); + Object.defineProperty(PropertyBindingParser.prototype._bindPropertyAst, "parameters", {get: function() { + return [[], [], [CompileElement], []]; + }}); + Object.defineProperty(PropertyBindingParser.prototype._bindEvent, "parameters", {get: function() { + return [[], [], [CompileElement], []]; + }}); } }; }); -System.register("angular2/src/core/annotations/di", ["angular2/src/core/annotations_impl/di"], function($__export) { +System.register("angular2/src/render/dom/compiler/text_interpolation_parser", ["angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/change_detection", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/annotations/di"; + var __moduleName = "angular2/src/render/dom/compiler/text_interpolation_parser"; + var RegExpWrapper, + StringWrapper, + isPresent, + DOM, + Parser, + CompileStep, + CompileElement, + CompileControl, + TextInterpolationParser; return { setters: [function($__m) { - $__export("QueryAnnotation", $__m.Query); - $__export("AttributeAnnotation", $__m.Attribute); + RegExpWrapper = $__m.RegExpWrapper; + StringWrapper = $__m.StringWrapper; + isPresent = $__m.isPresent; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + Parser = $__m.Parser; + }, function($__m) { + CompileStep = $__m.CompileStep; + }, function($__m) { + CompileElement = $__m.CompileElement; + }, function($__m) { + CompileControl = $__m.CompileControl; }], - execute: function() {} + execute: function() { + TextInterpolationParser = (function($__super) { + function TextInterpolationParser(parser) { + $traceurRuntime.superConstructor(TextInterpolationParser).call(this); + this._parser = parser; + } + return ($traceurRuntime.createClass)(TextInterpolationParser, {process: function(parent, current, control) { + if (!current.compileChildren) { + return ; + } + var element = current.element; + var childNodes = DOM.childNodes(DOM.templateAwareRoot(element)); + for (var i = 0; i < childNodes.length; i++) { + var node = childNodes[i]; + if (DOM.isTextNode(node)) { + var text = DOM.nodeValue(node); + var expr = this._parser.parseInterpolation(text, current.elementDescription); + if (isPresent(expr)) { + DOM.setText(node, ' '); + current.bindElement().bindText(i, expr); + } + } + } + }}, {}, $__super); + }(CompileStep)); + $__export("TextInterpolationParser", TextInterpolationParser); + Object.defineProperty(TextInterpolationParser, "parameters", {get: function() { + return [[Parser]]; + }}); + Object.defineProperty(TextInterpolationParser.prototype.process, "parameters", {get: function() { + return [[CompileElement], [CompileElement], [CompileControl]]; + }}); + } }; }); -System.register("angular2/src/render/dom/shadow_dom/native_shadow_dom_strategy", ["rtts_assert/rtts_assert", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/shadow_dom/util"], function($__export) { +System.register("angular2/src/render/dom/compiler/selector", ["angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/native_shadow_dom_strategy"; - var assert, - Promise, - DOM, - viewModule, - StyleUrlResolver, - ShadowDomStrategy, - moveViewNodesIntoParent, - NativeShadowDomStrategy; + var __moduleName = "angular2/src/render/dom/compiler/selector"; + var List, + Map, + ListWrapper, + MapWrapper, + isPresent, + isBlank, + RegExpWrapper, + RegExpMatcherWrapper, + StringWrapper, + BaseException, + _EMPTY_ATTR_VALUE, + _SELECTOR_REGEXP, + CssSelector, + SelectorMatcher, + SelectorListContext, + SelectorContext; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Promise = $__m.Promise; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - viewModule = $__m; - }, function($__m) { - StyleUrlResolver = $__m.StyleUrlResolver; - }, function($__m) { - ShadowDomStrategy = $__m.ShadowDomStrategy; + List = $__m.List; + Map = $__m.Map; + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; }, function($__m) { - moveViewNodesIntoParent = $__m.moveViewNodesIntoParent; + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + RegExpWrapper = $__m.RegExpWrapper; + RegExpMatcherWrapper = $__m.RegExpMatcherWrapper; + StringWrapper = $__m.StringWrapper; + BaseException = $__m.BaseException; }], execute: function() { - NativeShadowDomStrategy = (function($__super) { - function NativeShadowDomStrategy(styleUrlResolver) { - assert.argumentTypes(styleUrlResolver, StyleUrlResolver); - $traceurRuntime.superConstructor(NativeShadowDomStrategy).call(this); - this.styleUrlResolver = styleUrlResolver; + _EMPTY_ATTR_VALUE = ''; + _SELECTOR_REGEXP = RegExpWrapper.create('(\\:not\\()|' + '([-\\w]+)|' + '(?:\\.([-\\w]+))|' + '(?:\\[([-\\w*]+)(?:=([^\\]]*))?\\])|' + '(?:\\))|' + '(\\s*,\\s*)'); + CssSelector = (function() { + function CssSelector() { + this.element = null; + this.classNames = ListWrapper.create(); + this.attrs = ListWrapper.create(); + this.notSelector = null; } - return ($traceurRuntime.createClass)(NativeShadowDomStrategy, { - attachTemplate: function(el, view) { - assert.argumentTypes(el, assert.type.any, view, viewModule.RenderView); - moveViewNodesIntoParent(DOM.createShadowRoot(el), view); + return ($traceurRuntime.createClass)(CssSelector, { + isElementSelector: function() { + return isPresent(this.element) && ListWrapper.isEmpty(this.classNames) && ListWrapper.isEmpty(this.attrs) && isBlank(this.notSelector); + }, + setElement: function() { + var element = arguments[0] !== (void 0) ? arguments[0] : null; + if (isPresent(element)) { + element = element.toLowerCase(); + } + this.element = element; + }, + addAttribute: function(name) { + var value = arguments[1] !== (void 0) ? arguments[1] : _EMPTY_ATTR_VALUE; + ListWrapper.push(this.attrs, name.toLowerCase()); + if (isPresent(value)) { + value = value.toLowerCase(); + } else { + value = _EMPTY_ATTR_VALUE; + } + ListWrapper.push(this.attrs, value); + }, + addClassName: function(name) { + ListWrapper.push(this.classNames, name.toLowerCase()); + }, + toString: function() { + var res = ''; + if (isPresent(this.element)) { + res += this.element; + } + if (isPresent(this.classNames)) { + for (var i = 0; i < this.classNames.length; i++) { + res += '.' + this.classNames[i]; + } + } + if (isPresent(this.attrs)) { + for (var i = 0; i < this.attrs.length; ) { + var attrName = this.attrs[i++]; + var attrValue = this.attrs[i++]; + res += '[' + attrName; + if (attrValue.length > 0) { + res += '=' + attrValue; + } + res += ']'; + } + } + if (isPresent(this.notSelector)) { + res += ":not(" + this.notSelector.toString() + ")"; + } + return res; + } + }, {parse: function(selector) { + var results = ListWrapper.create(); + var _addResult = (function(res, cssSel) { + if (isPresent(cssSel.notSelector) && isBlank(cssSel.element) && ListWrapper.isEmpty(cssSel.classNames) && ListWrapper.isEmpty(cssSel.attrs)) { + cssSel.element = "*"; + } + ListWrapper.push(res, cssSel); + }); + var cssSelector = new CssSelector(); + var matcher = RegExpWrapper.matcher(_SELECTOR_REGEXP, selector); + var match; + var current = cssSelector; + while (isPresent(match = RegExpMatcherWrapper.next(matcher))) { + if (isPresent(match[1])) { + if (isPresent(cssSelector.notSelector)) { + throw new BaseException('Nesting :not is not allowed in a selector'); + } + current.notSelector = new CssSelector(); + current = current.notSelector; + } + if (isPresent(match[2])) { + current.setElement(match[2]); + } + if (isPresent(match[3])) { + current.addClassName(match[3]); + } + if (isPresent(match[4])) { + current.addAttribute(match[4], match[5]); + } + if (isPresent(match[6])) { + _addResult(results, cssSelector); + cssSelector = current = new CssSelector(); + } + } + _addResult(results, cssSelector); + return results; + }}); + }()); + $__export("CssSelector", CssSelector); + Object.defineProperty(CssSelector.parse, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(CssSelector.prototype.setElement, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + Object.defineProperty(CssSelector.prototype.addAttribute, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string]]; + }}); + Object.defineProperty(CssSelector.prototype.addClassName, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + SelectorMatcher = (function() { + function SelectorMatcher() { + this._elementMap = MapWrapper.create(); + this._elementPartialMap = MapWrapper.create(); + this._classMap = MapWrapper.create(); + this._classPartialMap = MapWrapper.create(); + this._attrValueMap = MapWrapper.create(); + this._attrValuePartialMap = MapWrapper.create(); + this._listContexts = ListWrapper.create(); + } + return ($traceurRuntime.createClass)(SelectorMatcher, { + addSelectables: function(cssSelectors, callbackCtxt) { + var listContext = null; + if (cssSelectors.length > 1) { + listContext = new SelectorListContext(cssSelectors); + ListWrapper.push(this._listContexts, listContext); + } + for (var i = 0; i < cssSelectors.length; i++) { + this.addSelectable(cssSelectors[i], callbackCtxt, listContext); + } + }, + addSelectable: function(cssSelector, callbackCtxt, listContext) { + var matcher = this; + var element = cssSelector.element; + var classNames = cssSelector.classNames; + var attrs = cssSelector.attrs; + var selectable = new SelectorContext(cssSelector, callbackCtxt, listContext); + if (isPresent(element)) { + var isTerminal = attrs.length === 0 && classNames.length === 0; + if (isTerminal) { + this._addTerminal(matcher._elementMap, element, selectable); + } else { + matcher = this._addPartial(matcher._elementPartialMap, element); + } + } + if (isPresent(classNames)) { + for (var index = 0; index < classNames.length; index++) { + var isTerminal = attrs.length === 0 && index === classNames.length - 1; + var className = classNames[index]; + if (isTerminal) { + this._addTerminal(matcher._classMap, className, selectable); + } else { + matcher = this._addPartial(matcher._classPartialMap, className); + } + } + } + if (isPresent(attrs)) { + for (var index = 0; index < attrs.length; ) { + var isTerminal = index === attrs.length - 2; + var attrName = attrs[index++]; + var attrValue = attrs[index++]; + var map = isTerminal ? matcher._attrValueMap : matcher._attrValuePartialMap; + var valuesMap = MapWrapper.get(map, attrName); + if (isBlank(valuesMap)) { + valuesMap = MapWrapper.create(); + MapWrapper.set(map, attrName, valuesMap); + } + if (isTerminal) { + this._addTerminal(valuesMap, attrValue, selectable); + } else { + matcher = this._addPartial(valuesMap, attrValue); + } + } + } + }, + _addTerminal: function(map, name, selectable) { + var terminalList = MapWrapper.get(map, name); + if (isBlank(terminalList)) { + terminalList = ListWrapper.create(); + MapWrapper.set(map, name, terminalList); + } + ListWrapper.push(terminalList, selectable); + }, + _addPartial: function(map, name) { + var matcher = MapWrapper.get(map, name); + if (isBlank(matcher)) { + matcher = new SelectorMatcher(); + MapWrapper.set(map, name, matcher); + } + return matcher; + }, + match: function(cssSelector, matchedCallback) { + var result = false; + var element = cssSelector.element; + var classNames = cssSelector.classNames; + var attrs = cssSelector.attrs; + for (var i = 0; i < this._listContexts.length; i++) { + this._listContexts[i].alreadyMatched = false; + } + result = this._matchTerminal(this._elementMap, element, cssSelector, matchedCallback) || result; + result = this._matchPartial(this._elementPartialMap, element, cssSelector, matchedCallback) || result; + if (isPresent(classNames)) { + for (var index = 0; index < classNames.length; index++) { + var className = classNames[index]; + result = this._matchTerminal(this._classMap, className, cssSelector, matchedCallback) || result; + result = this._matchPartial(this._classPartialMap, className, cssSelector, matchedCallback) || result; + } + } + if (isPresent(attrs)) { + for (var index = 0; index < attrs.length; ) { + var attrName = attrs[index++]; + var attrValue = attrs[index++]; + var valuesMap = MapWrapper.get(this._attrValueMap, attrName); + if (!StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) { + result = this._matchTerminal(valuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) || result; + } + result = this._matchTerminal(valuesMap, attrValue, cssSelector, matchedCallback) || result; + valuesMap = MapWrapper.get(this._attrValuePartialMap, attrName); + result = this._matchPartial(valuesMap, attrValue, cssSelector, matchedCallback) || result; + } + } + return result; }, - processStyleElement: function(hostComponentId, templateUrl, styleEl) { - assert.argumentTypes(hostComponentId, assert.type.string, templateUrl, assert.type.string, styleEl, assert.type.any); - var cssText = DOM.getText(styleEl); - cssText = this.styleUrlResolver.resolveUrls(cssText, templateUrl); - DOM.setText(styleEl, cssText); - return assert.returnType((null), Promise); - } - }, {}, $__super); - }(ShadowDomStrategy)); - $__export("NativeShadowDomStrategy", NativeShadowDomStrategy); - Object.defineProperty(NativeShadowDomStrategy, "parameters", {get: function() { - return [[StyleUrlResolver]]; - }}); - Object.defineProperty(NativeShadowDomStrategy.prototype.attachTemplate, "parameters", {get: function() { - return [[], [viewModule.RenderView]]; - }}); - Object.defineProperty(NativeShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/shadow_dom/emulated_scoped_shadow_dom_strategy", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/shadow_dom/style_inliner", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy", "angular2/src/render/dom/shadow_dom/util"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/emulated_scoped_shadow_dom_strategy"; - var assert, - isBlank, - isPresent, - PromiseWrapper, - Promise, - DOM, - StyleInliner, - StyleUrlResolver, - EmulatedUnscopedShadowDomStrategy, - getContentAttribute, - getHostAttribute, - getComponentId, - shimCssForComponent, - insertStyleElement, - EmulatedScopedShadowDomStrategy; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - }, function($__m) { - PromiseWrapper = $__m.PromiseWrapper; - Promise = $__m.Promise; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - StyleInliner = $__m.StyleInliner; - }, function($__m) { - StyleUrlResolver = $__m.StyleUrlResolver; - }, function($__m) { - EmulatedUnscopedShadowDomStrategy = $__m.EmulatedUnscopedShadowDomStrategy; - }, function($__m) { - getContentAttribute = $__m.getContentAttribute; - getHostAttribute = $__m.getHostAttribute; - getComponentId = $__m.getComponentId; - shimCssForComponent = $__m.shimCssForComponent; - insertStyleElement = $__m.insertStyleElement; - }], - execute: function() { - EmulatedScopedShadowDomStrategy = (function($__super) { - function EmulatedScopedShadowDomStrategy(styleInliner, styleUrlResolver, styleHost) { - assert.argumentTypes(styleInliner, StyleInliner, styleUrlResolver, StyleUrlResolver, styleHost, assert.type.any); - $traceurRuntime.superConstructor(EmulatedScopedShadowDomStrategy).call(this, styleUrlResolver, styleHost); - this.styleInliner = styleInliner; - } - return ($traceurRuntime.createClass)(EmulatedScopedShadowDomStrategy, { - processStyleElement: function(hostComponentId, templateUrl, styleEl) { - assert.argumentTypes(hostComponentId, assert.type.string, templateUrl, assert.type.string, styleEl, assert.type.any); - var cssText = DOM.getText(styleEl); - cssText = this.styleUrlResolver.resolveUrls(cssText, templateUrl); - var css = this.styleInliner.inlineImports(cssText, templateUrl); - if (PromiseWrapper.isPromise(css)) { - DOM.setText(styleEl, ''); - return assert.returnType((css.then((function(css) { - css = shimCssForComponent(css, hostComponentId); - DOM.setText(styleEl, css); - }))), Promise); - } else { - css = shimCssForComponent(css, hostComponentId); - DOM.setText(styleEl, css); + _matchTerminal: function() { + var map = arguments[0] !== (void 0) ? arguments[0] : null; + var name = arguments[1]; + var cssSelector = arguments[2]; + var matchedCallback = arguments[3]; + if (isBlank(map) || isBlank(name)) { + return false; } - DOM.remove(styleEl); - insertStyleElement(this.styleHost, styleEl); - return assert.returnType((null), Promise); + var selectables = MapWrapper.get(map, name); + var starSelectables = MapWrapper.get(map, "*"); + if (isPresent(starSelectables)) { + selectables = ListWrapper.concat(selectables, starSelectables); + } + if (isBlank(selectables)) { + return false; + } + var selectable; + var result = false; + for (var index = 0; index < selectables.length; index++) { + selectable = selectables[index]; + result = selectable.finalize(cssSelector, matchedCallback) || result; + } + return result; }, - processElement: function(hostComponentId, elementComponentId, element) { - assert.argumentTypes(hostComponentId, assert.type.string, elementComponentId, assert.type.string, element, assert.type.any); - if (isPresent(hostComponentId)) { - var contentAttribute = getContentAttribute(getComponentId(hostComponentId)); - DOM.setAttribute(element, contentAttribute, ''); + _matchPartial: function() { + var map = arguments[0] !== (void 0) ? arguments[0] : null; + var name = arguments[1]; + var cssSelector = arguments[2]; + var matchedCallback = arguments[3]; + if (isBlank(map) || isBlank(name)) { + return false; } - if (isPresent(elementComponentId)) { - var hostAttribute = getHostAttribute(getComponentId(elementComponentId)); - DOM.setAttribute(element, hostAttribute, ''); + var nestedSelector = MapWrapper.get(map, name); + if (isBlank(nestedSelector)) { + return false; } + return nestedSelector.match(cssSelector, matchedCallback); } - }, {}, $__super); - }(EmulatedUnscopedShadowDomStrategy)); - $__export("EmulatedScopedShadowDomStrategy", EmulatedScopedShadowDomStrategy); - Object.defineProperty(EmulatedScopedShadowDomStrategy, "parameters", {get: function() { - return [[StyleInliner], [StyleUrlResolver], []]; + }, {}); + }()); + $__export("SelectorMatcher", SelectorMatcher); + Object.defineProperty(SelectorMatcher.prototype.addSelectables, "parameters", {get: function() { + return [[assert.genericType(List, CssSelector)], []]; }}); - Object.defineProperty(EmulatedScopedShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; + Object.defineProperty(SelectorMatcher.prototype.addSelectable, "parameters", {get: function() { + return [[], [], [SelectorListContext]]; }}); - Object.defineProperty(EmulatedScopedShadowDomStrategy.prototype.processElement, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; + Object.defineProperty(SelectorMatcher.prototype._addTerminal, "parameters", {get: function() { + return [[assert.genericType(Map, assert.type.string, assert.type.string)], [assert.type.string], []]; }}); - } - }; -}); - -System.register("angular2/src/core/annotations/annotations", ["angular2/src/core/annotations_impl/annotations"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/annotations/annotations"; - return { - setters: [function($__m) { - $__export("ComponentAnnotation", $__m.Component); - $__export("DecoratorAnnotation", $__m.Decorator); - $__export("DirectiveAnnotation", $__m.Directive); - $__export("onDestroy", $__m.onDestroy); - $__export("onChange", $__m.onChange); - $__export("onAllChangesDone", $__m.onAllChangesDone); - }], - execute: function() {} - }; -}); - -System.register("angular2/src/core/decorators/decorators", ["angular2/src/core/annotations/annotations", "angular2/src/core/annotations/view", "angular2/src/core/annotations/visibility", "angular2/src/core/annotations/di"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/decorators/decorators"; - var ComponentAnnotation, - DecoratorAnnotation, - ViewAnnotation, - AncestorAnnotation, - ParentAnnotation, - AttributeAnnotation, - QueryAnnotation, - Component, - Decorator, - Attribute, - Query, - View, - Ancestor, - Parent; - function makeDecorator(annotationCls) { - return function() { - for (var args = [], - $__0 = 0; $__0 < arguments.length; $__0++) - args[$__0] = arguments[$__0]; - if (!(window.Reflect && window.Reflect.getMetadata)) - throw 'reflect-metadata shim is required'; - var annotationInstance = new (Function.prototype.bind.apply(annotationCls, $traceurRuntime.spread([null], args)))(); - var Reflect = window.Reflect; - return function(cls) { - var annotations = Reflect.getMetadata('annotations', cls); - annotations = annotations || []; - annotations.push(annotationInstance); - Reflect.defineMetadata('annotations', annotations, cls); - return cls; - }; - }; - } - return { - setters: [function($__m) { - ComponentAnnotation = $__m.ComponentAnnotation; - DecoratorAnnotation = $__m.DecoratorAnnotation; - }, function($__m) { - ViewAnnotation = $__m.ViewAnnotation; - }, function($__m) { - AncestorAnnotation = $__m.AncestorAnnotation; - ParentAnnotation = $__m.ParentAnnotation; - }, function($__m) { - AttributeAnnotation = $__m.AttributeAnnotation; - QueryAnnotation = $__m.QueryAnnotation; - }], - execute: function() { - Component = makeDecorator(ComponentAnnotation); - $__export("Component", Component); - Decorator = makeDecorator(DecoratorAnnotation); - $__export("Decorator", Decorator); - Attribute = makeDecorator(AttributeAnnotation); - $__export("Attribute", Attribute); - Query = makeDecorator(QueryAnnotation); - $__export("Query", Query); - View = makeDecorator(ViewAnnotation); - $__export("View", View); - Ancestor = makeDecorator(AncestorAnnotation); - $__export("Ancestor", Ancestor); - Parent = makeDecorator(ParentAnnotation); - $__export("Parent", Parent); - } - }; -}); - -System.register("angular2/src/directives/class", ["rtts_assert/rtts_assert", "angular2/src/core/annotations_impl/annotations", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/core/compiler/element_ref"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/directives/class"; - var assert, - Decorator, - isPresent, - DOM, - ElementRef, - CSSClass; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Decorator = $__m.Decorator; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - ElementRef = $__m.ElementRef; - }], - execute: function() { - CSSClass = (function() { - function CSSClass(ngEl) { - assert.argumentTypes(ngEl, ElementRef); - this._domEl = ngEl.domElement; + Object.defineProperty(SelectorMatcher.prototype._addPartial, "parameters", {get: function() { + return [[assert.genericType(Map, assert.type.string, assert.type.string)], [assert.type.string]]; + }}); + Object.defineProperty(SelectorMatcher.prototype.match, "parameters", {get: function() { + return [[CssSelector], [Function]]; + }}); + Object.defineProperty(SelectorMatcher.prototype._matchTerminal, "parameters", {get: function() { + return [[assert.genericType(Map, assert.type.string, assert.type.string)], [], [], []]; + }}); + Object.defineProperty(SelectorMatcher.prototype._matchPartial, "parameters", {get: function() { + return [[assert.genericType(Map, assert.type.string, assert.type.string)], [], [], []]; + }}); + SelectorListContext = (function() { + function SelectorListContext(selectors) { + this.selectors = selectors; + this.alreadyMatched = false; } - return ($traceurRuntime.createClass)(CSSClass, { - _toggleClass: function(className, enabled) { - if (enabled) { - DOM.addClass(this._domEl, className); - } else { - DOM.removeClass(this._domEl, className); + return ($traceurRuntime.createClass)(SelectorListContext, {}, {}); + }()); + Object.defineProperty(SelectorListContext, "parameters", {get: function() { + return [[assert.genericType(List, CssSelector)]]; + }}); + SelectorContext = (function() { + function SelectorContext(selector, cbContext, listContext) { + this.selector = selector; + this.notSelector = selector.notSelector; + this.cbContext = cbContext; + this.listContext = listContext; + } + return ($traceurRuntime.createClass)(SelectorContext, {finalize: function(cssSelector, callback) { + var result = true; + if (isPresent(this.notSelector) && (isBlank(this.listContext) || !this.listContext.alreadyMatched)) { + var notMatcher = new SelectorMatcher(); + notMatcher.addSelectable(this.notSelector, null, null); + result = !notMatcher.match(cssSelector, null); } - }, - set iterableChanges(changes) { - var $__0 = this; - if (isPresent(changes)) { - changes.forEachAddedItem((function(record) { - $__0._toggleClass(record.key, record.currentValue); - })); - changes.forEachChangedItem((function(record) { - $__0._toggleClass(record.key, record.currentValue); - })); - changes.forEachRemovedItem((function(record) { - if (record.previousValue) { - DOM.removeClass($__0._domEl, record.key); - } - })); + if (result && isPresent(callback) && (isBlank(this.listContext) || !this.listContext.alreadyMatched)) { + if (isPresent(this.listContext)) { + this.listContext.alreadyMatched = true; + } + callback(this.selector, this.cbContext); } - } - }, {}); + return result; + }}, {}); }()); - $__export("CSSClass", CSSClass); - Object.defineProperty(CSSClass, "annotations", {get: function() { - return [new Decorator({ - selector: '[class]', - properties: {'iterableChanges': 'class | keyValDiff'} - })]; + Object.defineProperty(SelectorContext, "parameters", {get: function() { + return [[CssSelector], [], [SelectorListContext]]; }}); - Object.defineProperty(CSSClass, "parameters", {get: function() { - return [[ElementRef]]; + Object.defineProperty(SelectorContext.prototype.finalize, "parameters", {get: function() { + return [[CssSelector], []]; }}); } }; }); -System.register("angular2/src/directives/for", ["rtts_assert/rtts_assert", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/view_ref", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { +System.register("angular2/src/render/dom/compiler/view_splitter", ["angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/change_detection", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/dom/util"], function($__export) { "use strict"; - var __moduleName = "angular2/src/directives/for"; - var assert, - Decorator, - ViewContainerRef, - ViewRef, - ProtoViewRef, + var __moduleName = "angular2/src/render/dom/compiler/view_splitter"; + var isBlank, isPresent, - isBlank, + BaseException, + StringWrapper, + DOM, + MapWrapper, ListWrapper, - For, - RecordViewTuple; + Parser, + CompileStep, + CompileElement, + CompileControl, + dashCaseToCamelCase, + ViewSplitter; return { setters: [function($__m) { - assert = $__m.assert; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + BaseException = $__m.BaseException; + StringWrapper = $__m.StringWrapper; }, function($__m) { - Decorator = $__m.Decorator; + DOM = $__m.DOM; }, function($__m) { - ViewContainerRef = $__m.ViewContainerRef; + MapWrapper = $__m.MapWrapper; + ListWrapper = $__m.ListWrapper; }, function($__m) { - ViewRef = $__m.ViewRef; - ProtoViewRef = $__m.ProtoViewRef; + Parser = $__m.Parser; }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; + CompileStep = $__m.CompileStep; }, function($__m) { - ListWrapper = $__m.ListWrapper; + CompileElement = $__m.CompileElement; + }, function($__m) { + CompileControl = $__m.CompileControl; + }, function($__m) { + dashCaseToCamelCase = $__m.dashCaseToCamelCase; }], execute: function() { - For = (function() { - function For(viewContainer, protoViewRef) { - assert.argumentTypes(viewContainer, ViewContainerRef, protoViewRef, ProtoViewRef); - this.viewContainer = viewContainer; - this.protoViewRef = protoViewRef; + ViewSplitter = (function($__super) { + function ViewSplitter(parser) { + $traceurRuntime.superConstructor(ViewSplitter).call(this); + this._parser = parser; } - return ($traceurRuntime.createClass)(For, { - set iterableChanges(changes) { - if (isBlank(changes)) { - this.viewContainer.clear(); - return ; - } - var recordViewTuples = []; - changes.forEachRemovedItem((function(removedRecord) { - return ListWrapper.push(recordViewTuples, new RecordViewTuple(removedRecord, null)); - })); - changes.forEachMovedItem((function(movedRecord) { - return ListWrapper.push(recordViewTuples, new RecordViewTuple(movedRecord, null)); - })); - var insertTuples = For.bulkRemove(recordViewTuples, this.viewContainer); - changes.forEachAddedItem((function(addedRecord) { - return ListWrapper.push(insertTuples, new RecordViewTuple(addedRecord, null)); + return ($traceurRuntime.createClass)(ViewSplitter, { + process: function(parent, current, control) { + var attrs = current.attrs(); + var templateBindings = MapWrapper.get(attrs, 'template'); + var hasTemplateBinding = isPresent(templateBindings); + MapWrapper.forEach(attrs, (function(attrValue, attrName) { + if (StringWrapper.startsWith(attrName, '*')) { + var key = StringWrapper.substring(attrName, 1); + if (hasTemplateBinding) { + throw new BaseException("Only one template directive per element is allowed: " + (templateBindings + " and " + key + " cannot be used simultaneously ") + ("in " + current.elementDescription)); + } else { + templateBindings = (attrValue.length == 0) ? key : key + ' ' + attrValue; + hasTemplateBinding = true; + } + } })); - For.bulkInsert(insertTuples, this.viewContainer, this.protoViewRef); - for (var i = 0; i < insertTuples.length; i++) { - this.perViewChange(insertTuples[i].view, insertTuples[i].record); + if (isPresent(parent)) { + if (DOM.isTemplateElement(current.element)) { + if (!current.isViewRoot) { + var viewRoot = new CompileElement(DOM.createTemplate('')); + viewRoot.inheritedProtoView = current.bindElement().bindNestedProtoView(viewRoot.element); + viewRoot.elementDescription = current.elementDescription; + viewRoot.isViewRoot = true; + this._moveChildNodes(DOM.content(current.element), DOM.content(viewRoot.element)); + control.addChild(viewRoot); + } + } + if (hasTemplateBinding) { + var newParent = new CompileElement(DOM.createTemplate('')); + newParent.inheritedProtoView = current.inheritedProtoView; + newParent.inheritedElementBinder = current.inheritedElementBinder; + newParent.distanceToInheritedBinder = current.distanceToInheritedBinder; + newParent.elementDescription = current.elementDescription; + current.inheritedProtoView = newParent.bindElement().bindNestedProtoView(current.element); + current.inheritedElementBinder = null; + current.distanceToInheritedBinder = 0; + current.isViewRoot = true; + this._parseTemplateBindings(templateBindings, newParent); + this._addParentElement(current.element, newParent.element); + control.addParent(newParent); + DOM.remove(current.element); + } } }, - perViewChange: function(view, record) { - view.setLocal('\$implicit', record.item); - view.setLocal('index', record.currentIndex); - } - }, { - bulkRemove: function(tuples, viewContainer) { - tuples.sort((function(a, b) { - return a.record.previousIndex - b.record.previousIndex; - })); - var movedTuples = []; - for (var i = tuples.length - 1; i >= 0; i--) { - var tuple = tuples[i]; - if (isPresent(tuple.record.currentIndex)) { - tuple.view = viewContainer.detach(tuple.record.previousIndex); - ListWrapper.push(movedTuples, tuple); - } else { - viewContainer.remove(tuple.record.previousIndex); - } + _moveChildNodes: function(source, target) { + var next = DOM.firstChild(source); + while (isPresent(next)) { + DOM.appendChild(target, next); + next = DOM.firstChild(source); } - return movedTuples; }, - bulkInsert: function(tuples, viewContainer, protoViewRef) { - tuples.sort((function(a, b) { - return a.record.currentIndex - b.record.currentIndex; - })); - for (var i = 0; i < tuples.length; i++) { - var tuple = tuples[i]; - if (isPresent(tuple.view)) { - viewContainer.insert(tuple.view, tuple.record.currentIndex); + _addParentElement: function(currentElement, newParentElement) { + DOM.insertBefore(currentElement, newParentElement); + DOM.appendChild(newParentElement, currentElement); + }, + _parseTemplateBindings: function(templateBindings, compileElement) { + var bindings = this._parser.parseTemplateBindings(templateBindings, compileElement.elementDescription); + for (var i = 0; i < bindings.length; i++) { + var binding = bindings[i]; + if (binding.keyIsVar) { + compileElement.bindElement().bindVariable(dashCaseToCamelCase(binding.key), binding.name); + MapWrapper.set(compileElement.attrs(), binding.key, binding.name); + } else if (isPresent(binding.expression)) { + compileElement.bindElement().bindProperty(dashCaseToCamelCase(binding.key), binding.expression); + MapWrapper.set(compileElement.attrs(), binding.key, binding.expression.source); } else { - tuple.view = viewContainer.create(protoViewRef, tuple.record.currentIndex); + DOM.setAttribute(compileElement.element, binding.key, ''); } } - return tuples; } - }); - }()); - $__export("For", For); - Object.defineProperty(For, "annotations", {get: function() { - return [new Decorator({ - selector: '[for][of]', - properties: {'iterableChanges': 'of | iterableDiff'} - })]; - }}); - Object.defineProperty(For, "parameters", {get: function() { - return [[ViewContainerRef], [ProtoViewRef]]; - }}); - RecordViewTuple = (function() { - function RecordViewTuple(record, view) { - this.record = record; - this.view = view; - } - return ($traceurRuntime.createClass)(RecordViewTuple, {}, {}); - }()); - } - }; -}); - -System.register("angular2/src/directives/if", ["rtts_assert/rtts_assert", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/view_ref", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/directives/if"; - var assert, - Decorator, - ViewContainerRef, - ProtoViewRef, - isBlank, - If; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Decorator = $__m.Decorator; - }, function($__m) { - ViewContainerRef = $__m.ViewContainerRef; - }, function($__m) { - ProtoViewRef = $__m.ProtoViewRef; - }, function($__m) { - isBlank = $__m.isBlank; - }], - execute: function() { - If = (function() { - function If(viewContainer, protoViewRef) { - assert.argumentTypes(viewContainer, ViewContainerRef, protoViewRef, ProtoViewRef); - this.viewContainer = viewContainer; - this.prevCondition = null; - this.protoViewRef = protoViewRef; - } - return ($traceurRuntime.createClass)(If, {set condition(newCondition) { - if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) { - this.prevCondition = true; - this.viewContainer.create(this.protoViewRef); - } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) { - this.prevCondition = false; - this.viewContainer.clear(); - } - }}, {}); - }()); - $__export("If", If); - Object.defineProperty(If, "annotations", {get: function() { - return [new Decorator({ - selector: '[if]', - properties: {'condition': 'if'} - })]; + }, {}, $__super); + }(CompileStep)); + $__export("ViewSplitter", ViewSplitter); + Object.defineProperty(ViewSplitter, "parameters", {get: function() { + return [[Parser]]; }}); - Object.defineProperty(If, "parameters", {get: function() { - return [[ViewContainerRef], [ProtoViewRef]]; + Object.defineProperty(ViewSplitter.prototype.process, "parameters", {get: function() { + return [[CompileElement], [CompileElement], [CompileControl]]; }}); - } - }; -}); - -System.register("angular2/src/directives/non_bindable", ["angular2/src/core/annotations_impl/annotations"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/directives/non_bindable"; - var Decorator, - NonBindable; - return { - setters: [function($__m) { - Decorator = $__m.Decorator; - }], - execute: function() { - NonBindable = (function() { - function NonBindable() {} - return ($traceurRuntime.createClass)(NonBindable, {}, {}); - }()); - $__export("NonBindable", NonBindable); - Object.defineProperty(NonBindable, "annotations", {get: function() { - return [new Decorator({ - selector: '[non-bindable]', - compileChildren: false - })]; + Object.defineProperty(ViewSplitter.prototype._parseTemplateBindings, "parameters", {get: function() { + return [[assert.type.string], [CompileElement]]; }}); } }; }); -System.register("angular2/src/directives/switch", ["rtts_assert/rtts_assert", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/view_ref", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/core/annotations_impl/visibility"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/shadow_dom_compile_step", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/api", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { "use strict"; - var __moduleName = "angular2/src/directives/switch"; - var assert, - Decorator, - ViewContainerRef, - ProtoViewRef, + var __moduleName = "angular2/src/render/dom/shadow_dom/shadow_dom_compile_step"; + var isBlank, isPresent, - isBlank, - normalizeBlank, - ListWrapper, - List, + assertionsEnabled, MapWrapper, - Map, - Parent, - SwitchView, - Switch, - SwitchWhen, - SwitchDefault, - _whenDefault; + List, + ListWrapper, + Promise, + PromiseWrapper, + DOM, + CompileStep, + CompileElement, + CompileControl, + ViewDefinition, + ShadowDomStrategy, + ShadowDomCompileStep; return { setters: [function($__m) { - assert = $__m.assert; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + assertionsEnabled = $__m.assertionsEnabled; }, function($__m) { - Decorator = $__m.Decorator; + MapWrapper = $__m.MapWrapper; + List = $__m.List; + ListWrapper = $__m.ListWrapper; }, function($__m) { - ViewContainerRef = $__m.ViewContainerRef; + Promise = $__m.Promise; + PromiseWrapper = $__m.PromiseWrapper; }, function($__m) { - ProtoViewRef = $__m.ProtoViewRef; + DOM = $__m.DOM; }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - normalizeBlank = $__m.normalizeBlank; + CompileStep = $__m.CompileStep; }, function($__m) { - ListWrapper = $__m.ListWrapper; - List = $__m.List; - MapWrapper = $__m.MapWrapper; - Map = $__m.Map; + CompileElement = $__m.CompileElement; }, function($__m) { - Parent = $__m.Parent; + CompileControl = $__m.CompileControl; + }, function($__m) { + ViewDefinition = $__m.ViewDefinition; + }, function($__m) { + ShadowDomStrategy = $__m.ShadowDomStrategy; }], execute: function() { - SwitchView = (function() { - function SwitchView(viewContainerRef, protoViewRef) { - assert.argumentTypes(viewContainerRef, ViewContainerRef, protoViewRef, ProtoViewRef); - this._protoViewRef = protoViewRef; - this._viewContainerRef = viewContainerRef; - } - return ($traceurRuntime.createClass)(SwitchView, { - create: function() { - this._viewContainerRef.create(this._protoViewRef); - }, - destroy: function() { - this._viewContainerRef.clear(); - } - }, {}); - }()); - Object.defineProperty(SwitchView, "parameters", {get: function() { - return [[ViewContainerRef], [ProtoViewRef]]; - }}); - Switch = (function() { - function Switch() { - this._valueViews = MapWrapper.create(); - this._activeViews = ListWrapper.create(); - this._useDefault = false; + ShadowDomCompileStep = (function($__super) { + function ShadowDomCompileStep(shadowDomStrategy, template, subTaskPromises) { + $traceurRuntime.superConstructor(ShadowDomCompileStep).call(this); + this._shadowDomStrategy = shadowDomStrategy; + this._template = template; + this._subTaskPromises = subTaskPromises; } - return ($traceurRuntime.createClass)(Switch, { - set value(value) { - this._emptyAllActiveViews(); - this._useDefault = false; - var views = MapWrapper.get(this._valueViews, value); - if (isBlank(views)) { - this._useDefault = true; - views = normalizeBlank(MapWrapper.get(this._valueViews, _whenDefault)); - } - this._activateViews(views); - this._switchValue = value; - }, - _onWhenValueChanged: function(oldWhen, newWhen, view) { - assert.argumentTypes(oldWhen, assert.type.any, newWhen, assert.type.any, view, SwitchView); - this._deregisterView(oldWhen, view); - this._registerView(newWhen, view); - if (oldWhen === this._switchValue) { - view.destroy(); - ListWrapper.remove(this._activeViews, view); - } else if (newWhen === this._switchValue) { - if (this._useDefault) { - this._useDefault = false; - this._emptyAllActiveViews(); - } - view.create(); - ListWrapper.push(this._activeViews, view); - } - if (this._activeViews.length === 0 && !this._useDefault) { - this._useDefault = true; - this._activateViews(MapWrapper.get(this._valueViews, _whenDefault)); - } - }, - _emptyAllActiveViews: function() { - var activeContainers = this._activeViews; - for (var i = 0; i < activeContainers.length; i++) { - activeContainers[i].destroy(); - } - this._activeViews = ListWrapper.create(); - }, - _activateViews: function(views) { - assert.argumentTypes(views, assert.genericType(List, SwitchView)); - if (isPresent(views)) { - for (var i = 0; i < views.length; i++) { - views[i].create(); - } - this._activeViews = views; + return ($traceurRuntime.createClass)(ShadowDomCompileStep, { + process: function(parent, current, control) { + var tagName = DOM.tagName(current.element).toUpperCase(); + if (tagName == 'STYLE') { + this._processStyleElement(current, control); + } else if (tagName == 'CONTENT') { + this._processContentElement(current); + } else { + var componentId = current.isBound() ? current.inheritedElementBinder.componentId : null; + this._shadowDomStrategy.processElement(this._template.componentId, componentId, current.element); } }, - _registerView: function(value, view) { - assert.argumentTypes(value, assert.type.any, view, SwitchView); - var views = MapWrapper.get(this._valueViews, value); - if (isBlank(views)) { - views = ListWrapper.create(); - MapWrapper.set(this._valueViews, value, views); + _processStyleElement: function(current, control) { + var stylePromise = this._shadowDomStrategy.processStyleElement(this._template.componentId, this._template.absUrl, current.element); + if (isPresent(stylePromise) && PromiseWrapper.isPromise(stylePromise)) { + ListWrapper.push(this._subTaskPromises, stylePromise); } - ListWrapper.push(views, view); + control.ignoreCurrentElement(); }, - _deregisterView: function(value, view) { - assert.argumentTypes(value, assert.type.any, view, SwitchView); - if (value == _whenDefault) + _processContentElement: function(current) { + if (this._shadowDomStrategy.hasNativeContentElement()) { return ; - var views = MapWrapper.get(this._valueViews, value); - if (views.length == 1) { - MapWrapper.delete(this._valueViews, value); - } else { - ListWrapper.remove(views, view); } + var attrs = current.attrs(); + var selector = MapWrapper.get(attrs, 'select'); + selector = isPresent(selector) ? selector : ''; + var contentStart = DOM.createScriptTag('type', 'ng/contentStart'); + if (assertionsEnabled()) { + DOM.setAttribute(contentStart, 'select', selector); + } + var contentEnd = DOM.createScriptTag('type', 'ng/contentEnd'); + DOM.insertBefore(current.element, contentStart); + DOM.insertBefore(current.element, contentEnd); + DOM.remove(current.element); + current.element = contentStart; + current.bindElement().setContentTagSelector(selector); } - }, {}); - }()); - $__export("Switch", Switch); - Object.defineProperty(Switch, "annotations", {get: function() { - return [new Decorator({ - selector: '[switch]', - properties: {'value': 'switch'} - })]; - }}); - Object.defineProperty(Switch.prototype._onWhenValueChanged, "parameters", {get: function() { - return [[], [], [SwitchView]]; - }}); - Object.defineProperty(Switch.prototype._activateViews, "parameters", {get: function() { - return [[assert.genericType(List, SwitchView)]]; - }}); - Object.defineProperty(Switch.prototype._registerView, "parameters", {get: function() { - return [[], [SwitchView]]; - }}); - Object.defineProperty(Switch.prototype._deregisterView, "parameters", {get: function() { - return [[], [SwitchView]]; - }}); - SwitchWhen = (function() { - function SwitchWhen(viewContainer, protoViewRef, sswitch) { - assert.argumentTypes(viewContainer, ViewContainerRef, protoViewRef, ProtoViewRef, sswitch, Switch); - this._value = _whenDefault; - this._switch = sswitch; - this._view = new SwitchView(viewContainer, protoViewRef); - } - return ($traceurRuntime.createClass)(SwitchWhen, { - onDestroy: function() { - this._switch; - }, - set when(value) { - this._switch._onWhenValueChanged(this._value, value, this._view); - this._value = value; - } - }, {}); - }()); - $__export("SwitchWhen", SwitchWhen); - Object.defineProperty(SwitchWhen, "annotations", {get: function() { - return [new Decorator({ - selector: '[switch-when]', - properties: {'when': 'switch-when'} - })]; + }, {}, $__super); + }(CompileStep)); + $__export("ShadowDomCompileStep", ShadowDomCompileStep); + Object.defineProperty(ShadowDomCompileStep, "parameters", {get: function() { + return [[ShadowDomStrategy], [ViewDefinition], [assert.genericType(List, Promise)]]; }}); - Object.defineProperty(SwitchWhen, "parameters", {get: function() { - return [[ViewContainerRef], [ProtoViewRef], [Switch, new Parent()]]; + Object.defineProperty(ShadowDomCompileStep.prototype.process, "parameters", {get: function() { + return [[CompileElement], [CompileElement], [CompileControl]]; }}); - SwitchDefault = (function() { - function SwitchDefault(viewContainer, protoViewRef, sswitch) { - assert.argumentTypes(viewContainer, ViewContainerRef, protoViewRef, ProtoViewRef, sswitch, Switch); - sswitch._registerView(_whenDefault, new SwitchView(viewContainer, protoViewRef)); - } - return ($traceurRuntime.createClass)(SwitchDefault, {}, {}); - }()); - $__export("SwitchDefault", SwitchDefault); - Object.defineProperty(SwitchDefault, "annotations", {get: function() { - return [new Decorator({selector: '[switch-default]'})]; + Object.defineProperty(ShadowDomCompileStep.prototype._processStyleElement, "parameters", {get: function() { + return [[CompileElement], [CompileControl]]; }}); - Object.defineProperty(SwitchDefault, "parameters", {get: function() { - return [[ViewContainerRef], [ProtoViewRef], [Switch, new Parent()]]; + Object.defineProperty(ShadowDomCompileStep.prototype._processContentElement, "parameters", {get: function() { + return [[CompileElement]]; }}); - _whenDefault = new Object(); } }; }); -System.register("angular2/src/forms/validators", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/forms/model"], function($__export) { +System.register("angular2/src/core/application_tokens", ["angular2/di"], function($__export) { "use strict"; - var __moduleName = "angular2/src/forms/validators"; - var assert, - isBlank, - isPresent, - List, - ListWrapper, - StringMapWrapper, - modelModule, - Validators; + var __moduleName = "angular2/src/core/application_tokens"; + var OpaqueToken, + appComponentRefToken, + appComponentAnnotatedTypeToken; + return { + setters: [function($__m) { + OpaqueToken = $__m.OpaqueToken; + }], + execute: function() { + appComponentRefToken = new OpaqueToken('ComponentRef'); + $__export("appComponentRefToken", appComponentRefToken); + appComponentAnnotatedTypeToken = new OpaqueToken('AppComponentAnnotatedType'); + $__export("appComponentAnnotatedTypeToken", appComponentAnnotatedTypeToken); + } + }; +}); + +System.register("angular2/src/core/annotations/di", ["angular2/src/core/annotations_impl/di"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/annotations/di"; + return { + setters: [function($__m) { + $__export("QueryAnnotation", $__m.Query); + $__export("AttributeAnnotation", $__m.Attribute); + }], + execute: function() {} + }; +}); + +System.register("angular2/src/render/dom/shadow_dom/native_shadow_dom_strategy", ["angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/shadow_dom/native_shadow_dom_strategy"; + var Promise, + DOM, + StyleUrlResolver, + ShadowDomStrategy, + NativeShadowDomStrategy; return { setters: [function($__m) { - assert = $__m.assert; + Promise = $__m.Promise; }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; + DOM = $__m.DOM; }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - StringMapWrapper = $__m.StringMapWrapper; + StyleUrlResolver = $__m.StyleUrlResolver; }, function($__m) { - modelModule = $__m; + ShadowDomStrategy = $__m.ShadowDomStrategy; }], execute: function() { - Validators = (function() { - function Validators() {} - return ($traceurRuntime.createClass)(Validators, {}, { - required: function(c) { - assert.argumentTypes(c, modelModule.Control); - return isBlank(c.value) || c.value == "" ? {"required": true} : null; + NativeShadowDomStrategy = (function($__super) { + function NativeShadowDomStrategy(styleUrlResolver) { + $traceurRuntime.superConstructor(NativeShadowDomStrategy).call(this); + this.styleUrlResolver = styleUrlResolver; + } + return ($traceurRuntime.createClass)(NativeShadowDomStrategy, { + prepareShadowRoot: function(el) { + return DOM.createShadowRoot(el); }, - nullValidator: function(c) { - assert.argumentTypes(c, assert.type.any); + processStyleElement: function(hostComponentId, templateUrl, styleEl) { + var cssText = DOM.getText(styleEl); + cssText = this.styleUrlResolver.resolveUrls(cssText, templateUrl); + DOM.setText(styleEl, cssText); return null; - }, - compose: function(validators) { - assert.argumentTypes(validators, assert.genericType(List, Function)); - return assert.returnType((function(c) { - assert.argumentTypes(c, modelModule.Control); - var res = ListWrapper.reduce(validators, (function(res, validator) { - var errors = validator(c); - return isPresent(errors) ? StringMapWrapper.merge(res, errors) : res; - }), {}); - return StringMapWrapper.isEmpty(res) ? null : res; - }), Function); - }, - group: function(c) { - assert.argumentTypes(c, modelModule.ControlGroup); - var res = {}; - StringMapWrapper.forEach(c.controls, (function(control, name) { - if (c.contains(name) && isPresent(control.errors)) { - Validators._mergeErrors(control, res); - } - })); - return StringMapWrapper.isEmpty(res) ? null : res; - }, - array: function(c) { - assert.argumentTypes(c, modelModule.ControlArray); - var res = {}; - ListWrapper.forEach(c.controls, (function(control) { - if (isPresent(control.errors)) { - Validators._mergeErrors(control, res); - } - })); - return StringMapWrapper.isEmpty(res) ? null : res; - }, - _mergeErrors: function(control, res) { - StringMapWrapper.forEach(control.errors, (function(value, error) { - if (!StringMapWrapper.contains(res, error)) { - res[error] = []; - } - ListWrapper.push(res[error], control); - })); } - }); - }()); - $__export("Validators", Validators); - Object.defineProperty(Validators.required, "parameters", {get: function() { - return [[modelModule.Control]]; - }}); - Object.defineProperty(Validators.nullValidator, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - Object.defineProperty(Validators.compose, "parameters", {get: function() { - return [[assert.genericType(List, Function)]]; - }}); - Object.defineProperty(Validators.group, "parameters", {get: function() { - return [[modelModule.ControlGroup]]; + }, {}, $__super); + }(ShadowDomStrategy)); + $__export("NativeShadowDomStrategy", NativeShadowDomStrategy); + Object.defineProperty(NativeShadowDomStrategy, "parameters", {get: function() { + return [[StyleUrlResolver]]; }}); - Object.defineProperty(Validators.array, "parameters", {get: function() { - return [[modelModule.ControlArray]]; + Object.defineProperty(NativeShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], []]; }}); } }; }); -System.register("angular2/src/forms/directives", ["rtts_assert/rtts_assert", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/annotations_impl/visibility", "angular2/src/core/compiler/element_ref", "angular2/di", "angular2/src/render/api", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/forms/model", "angular2/src/forms/validators"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/emulated_scoped_shadow_dom_strategy", ["angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/shadow_dom/style_inliner", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy", "angular2/src/render/dom/shadow_dom/util"], function($__export) { "use strict"; - var __moduleName = "angular2/src/forms/directives"; - var assert, - Decorator, - onChange, - Ancestor, - ElementRef, - Optional, - Renderer, + var __moduleName = "angular2/src/render/dom/shadow_dom/emulated_scoped_shadow_dom_strategy"; + var isBlank, isPresent, - isString, - ListWrapper, - ControlGroup, - Validators, - DefaultValueAccessor, - CheckboxControlValueAccessor, - ControlDirective, - ControlGroupDirective, - FormDirectives; + PromiseWrapper, + Promise, + DOM, + StyleInliner, + StyleUrlResolver, + EmulatedUnscopedShadowDomStrategy, + getContentAttribute, + getHostAttribute, + getComponentId, + shimCssForComponent, + insertStyleElement, + EmulatedScopedShadowDomStrategy; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Decorator = $__m.Decorator; - onChange = $__m.onChange; - }, function($__m) { - Ancestor = $__m.Ancestor; - }, function($__m) { - ElementRef = $__m.ElementRef; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; }, function($__m) { - Optional = $__m.Optional; + PromiseWrapper = $__m.PromiseWrapper; + Promise = $__m.Promise; }, function($__m) { - Renderer = $__m.Renderer; + DOM = $__m.DOM; }, function($__m) { - isPresent = $__m.isPresent; - isString = $__m.isString; + StyleInliner = $__m.StyleInliner; }, function($__m) { - ListWrapper = $__m.ListWrapper; + StyleUrlResolver = $__m.StyleUrlResolver; }, function($__m) { - ControlGroup = $__m.ControlGroup; + EmulatedUnscopedShadowDomStrategy = $__m.EmulatedUnscopedShadowDomStrategy; }, function($__m) { - Validators = $__m.Validators; + getContentAttribute = $__m.getContentAttribute; + getHostAttribute = $__m.getHostAttribute; + getComponentId = $__m.getComponentId; + shimCssForComponent = $__m.shimCssForComponent; + insertStyleElement = $__m.insertStyleElement; }], execute: function() { - DefaultValueAccessor = (function() { - function DefaultValueAccessor() { - this.onChange = (function(_) {}); - } - return ($traceurRuntime.createClass)(DefaultValueAccessor, {writeValue: function(value) { - this.value = value; - }}, {}); - }()); - $__export("DefaultValueAccessor", DefaultValueAccessor); - Object.defineProperty(DefaultValueAccessor, "annotations", {get: function() { - return [new Decorator({ - selector: '[control]', - hostListeners: { - 'change': 'onChange($event.target.value)', - 'input': 'onChange($event.target.value)' - }, - hostProperties: {'value': 'value'} - })]; - }}); - CheckboxControlValueAccessor = (function() { - function CheckboxControlValueAccessor(cd, elementRef, renderer) { - assert.argumentTypes(cd, ControlDirective, elementRef, ElementRef, renderer, Renderer); - this.onChange = (function(_) {}); - this._elementRef = elementRef; - this._renderer = renderer; - cd.valueAccessor = this; - } - return ($traceurRuntime.createClass)(CheckboxControlValueAccessor, {writeValue: function(value) { - this._renderer.setElementProperty(this._elementRef.parentView.render, this._elementRef.boundElementIndex, 'checked', value); - }}, {}); - }()); - $__export("CheckboxControlValueAccessor", CheckboxControlValueAccessor); - Object.defineProperty(CheckboxControlValueAccessor, "annotations", {get: function() { - return [new Decorator({ - selector: 'input[type=checkbox][control]', - hostListeners: {'change': 'onChange($event.target.checked)'}, - hostProperties: {'checked': 'checked'} - })]; - }}); - Object.defineProperty(CheckboxControlValueAccessor, "parameters", {get: function() { - return [[ControlDirective], [ElementRef], [Renderer]]; - }}); - ControlDirective = (function() { - function ControlDirective(groupDirective, valueAccessor) { - assert.argumentTypes(groupDirective, ControlGroupDirective, valueAccessor, DefaultValueAccessor); - this._groupDirective = groupDirective; - this.controlOrName = null; - this.valueAccessor = valueAccessor; - this.validator = Validators.nullValidator; - } - return ($traceurRuntime.createClass)(ControlDirective, { - onChange: function(_) { - this._initialize(); - }, - _initialize: function() { - if (isPresent(this._groupDirective)) { - this._groupDirective.addDirective(this); - } - var c = this._control(); - c.validator = Validators.compose([c.validator, this.validator]); - this._updateDomValue(); - this._setUpUpdateControlValue(); - }, - _updateDomValue: function() { - this.valueAccessor.writeValue(this._control().value); - }, - _setUpUpdateControlValue: function() { - var $__0 = this; - this.valueAccessor.onChange = (function(newValue) { - return $__0._control().updateValue(newValue); - }); - }, - _control: function() { - if (isString(this.controlOrName)) { - return this._groupDirective.findControl(this.controlOrName); - } else { - return this.controlOrName; - } - } - }, {}); - }()); - $__export("ControlDirective", ControlDirective); - Object.defineProperty(ControlDirective, "annotations", {get: function() { - return [new Decorator({ - lifecycle: [onChange], - selector: '[control]', - properties: {'controlOrName': 'control'} - })]; - }}); - Object.defineProperty(ControlDirective, "parameters", {get: function() { - return [[ControlGroupDirective, new Optional(), new Ancestor()], [DefaultValueAccessor]]; - }}); - ControlGroupDirective = (function() { - function ControlGroupDirective(groupDirective) { - assert.argumentTypes(groupDirective, ControlGroupDirective); - this._groupDirective = groupDirective; - this._directives = ListWrapper.create(); + EmulatedScopedShadowDomStrategy = (function($__super) { + function EmulatedScopedShadowDomStrategy(styleInliner, styleUrlResolver, styleHost) { + $traceurRuntime.superConstructor(EmulatedScopedShadowDomStrategy).call(this, styleUrlResolver, styleHost); + this.styleInliner = styleInliner; } - return ($traceurRuntime.createClass)(ControlGroupDirective, { - set controlGroup(controlGroup) { - if (isString(controlGroup)) { - this._controlGroupName = controlGroup; - } else { - this._controlGroup = controlGroup; - } - this._updateDomValue(); - }, - _updateDomValue: function() { - ListWrapper.forEach(this._directives, (function(cd) { - return cd._updateDomValue(); - })); - }, - addDirective: function(c) { - assert.argumentTypes(c, ControlDirective); - ListWrapper.push(this._directives, c); - }, - findControl: function(name) { - assert.argumentTypes(name, assert.type.string); - return assert.returnType((this._getControlGroup().controls[name]), assert.type.any); - }, - _getControlGroup: function() { - if (isPresent(this._controlGroupName)) { - return assert.returnType((this._groupDirective.findControl(this._controlGroupName)), ControlGroup); + return ($traceurRuntime.createClass)(EmulatedScopedShadowDomStrategy, { + processStyleElement: function(hostComponentId, templateUrl, styleEl) { + var cssText = DOM.getText(styleEl); + cssText = this.styleUrlResolver.resolveUrls(cssText, templateUrl); + var css = this.styleInliner.inlineImports(cssText, templateUrl); + if (PromiseWrapper.isPromise(css)) { + DOM.setText(styleEl, ''); + return css.then((function(css) { + css = shimCssForComponent(css, hostComponentId); + DOM.setText(styleEl, css); + })); } else { - return assert.returnType((this._controlGroup), ControlGroup); + css = shimCssForComponent(css, hostComponentId); + DOM.setText(styleEl, css); + } + DOM.remove(styleEl); + insertStyleElement(this.styleHost, styleEl); + return null; + }, + processElement: function(hostComponentId, elementComponentId, element) { + if (isPresent(hostComponentId)) { + var contentAttribute = getContentAttribute(getComponentId(hostComponentId)); + DOM.setAttribute(element, contentAttribute, ''); + } + if (isPresent(elementComponentId)) { + var hostAttribute = getHostAttribute(getComponentId(elementComponentId)); + DOM.setAttribute(element, hostAttribute, ''); } } - }, {}); - }()); - $__export("ControlGroupDirective", ControlGroupDirective); - Object.defineProperty(ControlGroupDirective, "annotations", {get: function() { - return [new Decorator({ - selector: '[control-group]', - properties: {'controlGroup': 'control-group'} - })]; - }}); - Object.defineProperty(ControlGroupDirective, "parameters", {get: function() { - return [[ControlGroupDirective, new Optional(), new Ancestor()]]; + }, {}, $__super); + }(EmulatedUnscopedShadowDomStrategy)); + $__export("EmulatedScopedShadowDomStrategy", EmulatedScopedShadowDomStrategy); + Object.defineProperty(EmulatedScopedShadowDomStrategy, "parameters", {get: function() { + return [[StyleInliner], [StyleUrlResolver], []]; }}); - Object.defineProperty(ControlGroupDirective.prototype.addDirective, "parameters", {get: function() { - return [[ControlDirective]]; + Object.defineProperty(EmulatedScopedShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], []]; }}); - Object.defineProperty(ControlGroupDirective.prototype.findControl, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(EmulatedScopedShadowDomStrategy.prototype.processElement, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], []]; }}); - FormDirectives = [ControlGroupDirective, ControlDirective, CheckboxControlValueAccessor, DefaultValueAccessor]; - $__export("FormDirectives", FormDirectives); } }; }); -System.register("angular2/src/forms/validator_directives", ["rtts_assert/rtts_assert", "angular2/src/core/annotations_impl/annotations", "angular2/src/forms/validators", "angular2/src/forms/directives"], function($__export) { +System.register("angular2/src/core/annotations/annotations", ["angular2/src/core/annotations_impl/annotations"], function($__export) { "use strict"; - var __moduleName = "angular2/src/forms/validator_directives"; - var assert, - Decorator, - Validators, - ControlDirective, - RequiredValidatorDirective; + var __moduleName = "angular2/src/core/annotations/annotations"; + return { + setters: [function($__m) { + $__export("ComponentAnnotation", $__m.Component); + $__export("DirectiveAnnotation", $__m.Directive); + $__export("onDestroy", $__m.onDestroy); + $__export("onChange", $__m.onChange); + $__export("onAllChangesDone", $__m.onAllChangesDone); + }], + execute: function() {} + }; +}); + +System.register("angular2/src/core/annotations/decorators", ["angular2/src/core/annotations/annotations", "angular2/src/core/annotations/view", "angular2/src/core/annotations/visibility", "angular2/src/core/annotations/di", "angular2/src/util/decorators"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/annotations/decorators"; + var ComponentAnnotation, + DirectiveAnnotation, + ViewAnnotation, + AncestorAnnotation, + ParentAnnotation, + AttributeAnnotation, + QueryAnnotation, + makeDecorator, + makeParamDecorator, + Component, + Directive, + View, + Ancestor, + Parent, + Attribute, + Query; return { setters: [function($__m) { - assert = $__m.assert; + ComponentAnnotation = $__m.ComponentAnnotation; + DirectiveAnnotation = $__m.DirectiveAnnotation; + }, function($__m) { + ViewAnnotation = $__m.ViewAnnotation; }, function($__m) { - Decorator = $__m.Decorator; + AncestorAnnotation = $__m.AncestorAnnotation; + ParentAnnotation = $__m.ParentAnnotation; }, function($__m) { - Validators = $__m.Validators; + AttributeAnnotation = $__m.AttributeAnnotation; + QueryAnnotation = $__m.QueryAnnotation; }, function($__m) { - ControlDirective = $__m.ControlDirective; + makeDecorator = $__m.makeDecorator; + makeParamDecorator = $__m.makeParamDecorator; }], execute: function() { - RequiredValidatorDirective = (function() { - function RequiredValidatorDirective(c) { - assert.argumentTypes(c, ControlDirective); - c.validator = Validators.compose([c.validator, Validators.required]); - } - return ($traceurRuntime.createClass)(RequiredValidatorDirective, {}, {}); - }()); - $__export("RequiredValidatorDirective", RequiredValidatorDirective); - Object.defineProperty(RequiredValidatorDirective, "annotations", {get: function() { - return [new Decorator({selector: '[required]'})]; - }}); - Object.defineProperty(RequiredValidatorDirective, "parameters", {get: function() { - return [[ControlDirective]]; - }}); + Component = makeDecorator(ComponentAnnotation); + $__export("Component", Component); + Directive = makeDecorator(DirectiveAnnotation); + $__export("Directive", Directive); + View = makeDecorator(ViewAnnotation); + $__export("View", View); + Ancestor = makeParamDecorator(AncestorAnnotation); + $__export("Ancestor", Ancestor); + Parent = makeParamDecorator(ParentAnnotation); + $__export("Parent", Parent); + Attribute = makeParamDecorator(AttributeAnnotation); + $__export("Attribute", Attribute); + Query = makeParamDecorator(QueryAnnotation); + $__export("Query", Query); } }; }); -System.register("angular2/src/forms/form_builder", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/forms/model"], function($__export) { +System.register("angular2/src/directives/ng_for", ["angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/view_ref", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { "use strict"; - var __moduleName = "angular2/src/forms/form_builder"; - var assert, - StringMapWrapper, - ListWrapper, - List, + var __moduleName = "angular2/src/directives/ng_for"; + var Directive, + ViewContainerRef, + ViewRef, + ProtoViewRef, isPresent, - modelModule, - FormBuilder; + isBlank, + ListWrapper, + NgFor, + RecordViewTuple; return { setters: [function($__m) { - assert = $__m.assert; + Directive = $__m.Directive; }, function($__m) { - StringMapWrapper = $__m.StringMapWrapper; - ListWrapper = $__m.ListWrapper; - List = $__m.List; + ViewContainerRef = $__m.ViewContainerRef; + }, function($__m) { + ViewRef = $__m.ViewRef; + ProtoViewRef = $__m.ProtoViewRef; }, function($__m) { isPresent = $__m.isPresent; + isBlank = $__m.isBlank; }, function($__m) { - modelModule = $__m; + ListWrapper = $__m.ListWrapper; }], execute: function() { - FormBuilder = (function() { - function FormBuilder() {} - return ($traceurRuntime.createClass)(FormBuilder, { - group: function(controlsConfig) { - var extra = arguments[1] !== (void 0) ? arguments[1] : null; - var controls = this._reduceControls(controlsConfig); - var optionals = isPresent(extra) ? StringMapWrapper.get(extra, "optionals") : null; - var validator = isPresent(extra) ? StringMapWrapper.get(extra, "validator") : null; - if (isPresent(validator)) { - return assert.returnType((new modelModule.ControlGroup(controls, optionals, validator)), modelModule.ControlGroup); - } else { - return assert.returnType((new modelModule.ControlGroup(controls, optionals)), modelModule.ControlGroup); + NgFor = (function() { + function NgFor(viewContainer, protoViewRef) { + this.viewContainer = viewContainer; + this.protoViewRef = protoViewRef; + } + return ($traceurRuntime.createClass)(NgFor, { + set iterableChanges(changes) { + if (isBlank(changes)) { + this.viewContainer.clear(); + return ; } - }, - control: function(value) { - var validator = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(value, assert.type.any, validator, Function); - if (isPresent(validator)) { - return assert.returnType((new modelModule.Control(value, validator)), modelModule.Control); - } else { - return assert.returnType((new modelModule.Control(value)), modelModule.Control); + var recordViewTuples = []; + changes.forEachRemovedItem((function(removedRecord) { + return ListWrapper.push(recordViewTuples, new RecordViewTuple(removedRecord, null)); + })); + changes.forEachMovedItem((function(movedRecord) { + return ListWrapper.push(recordViewTuples, new RecordViewTuple(movedRecord, null)); + })); + var insertTuples = NgFor.bulkRemove(recordViewTuples, this.viewContainer); + changes.forEachAddedItem((function(addedRecord) { + return ListWrapper.push(insertTuples, new RecordViewTuple(addedRecord, null)); + })); + NgFor.bulkInsert(insertTuples, this.viewContainer, this.protoViewRef); + for (var i = 0; i < insertTuples.length; i++) { + this.perViewChange(insertTuples[i].view, insertTuples[i].record); } }, - array: function(controlsConfig) { - var validator = arguments[1] !== (void 0) ? arguments[1] : null; - var $__0 = this; - var controls = ListWrapper.map(controlsConfig, (function(c) { - return $__0._createControl(c); + perViewChange: function(view, record) { + view.setLocal('\$implicit', record.item); + view.setLocal('index', record.currentIndex); + } + }, { + bulkRemove: function(tuples, viewContainer) { + tuples.sort((function(a, b) { + return a.record.previousIndex - b.record.previousIndex; })); - if (isPresent(validator)) { - return assert.returnType((new modelModule.ControlArray(controls, validator)), modelModule.ControlArray); - } else { - return assert.returnType((new modelModule.ControlArray(controls)), modelModule.ControlArray); + var movedTuples = []; + for (var i = tuples.length - 1; i >= 0; i--) { + var tuple = tuples[i]; + if (isPresent(tuple.record.currentIndex)) { + tuple.view = viewContainer.detach(tuple.record.previousIndex); + ListWrapper.push(movedTuples, tuple); + } else { + viewContainer.remove(tuple.record.previousIndex); + } } + return movedTuples; }, - _reduceControls: function(controlsConfig) { - var $__0 = this; - var controls = {}; - StringMapWrapper.forEach(controlsConfig, (function(controlConfig, controlName) { - controls[controlName] = $__0._createControl(controlConfig); + bulkInsert: function(tuples, viewContainer, protoViewRef) { + tuples.sort((function(a, b) { + return a.record.currentIndex - b.record.currentIndex; })); - return controls; - }, - _createControl: function(controlConfig) { - if (controlConfig instanceof modelModule.Control || controlConfig instanceof modelModule.ControlGroup || controlConfig instanceof modelModule.ControlArray) { - return controlConfig; - } else if (ListWrapper.isList(controlConfig)) { - var value = ListWrapper.get(controlConfig, 0); - var validator = controlConfig.length > 1 ? controlConfig[1] : null; - return this.control(value, validator); - } else { - return this.control(controlConfig); + for (var i = 0; i < tuples.length; i++) { + var tuple = tuples[i]; + if (isPresent(tuple.view)) { + viewContainer.insert(tuple.view, tuple.record.currentIndex); + } else { + tuple.view = viewContainer.create(protoViewRef, tuple.record.currentIndex); + } + } + return tuples; + } + }); + }()); + $__export("NgFor", NgFor); + Object.defineProperty(NgFor, "annotations", {get: function() { + return [new Directive({ + selector: '[ng-for][ng-for-of]', + properties: {'iterableChanges': 'ngForOf | iterableDiff'} + })]; + }}); + Object.defineProperty(NgFor, "parameters", {get: function() { + return [[ViewContainerRef], [ProtoViewRef]]; + }}); + RecordViewTuple = (function() { + function RecordViewTuple(record, view) { + this.record = record; + this.view = view; + } + return ($traceurRuntime.createClass)(RecordViewTuple, {}, {}); + }()); + } + }; +}); + +System.register("angular2/src/directives/ng_if", ["angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/view_ref", "angular2/src/facade/lang"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/directives/ng_if"; + var Directive, + ViewContainerRef, + ProtoViewRef, + isBlank, + NgIf; + return { + setters: [function($__m) { + Directive = $__m.Directive; + }, function($__m) { + ViewContainerRef = $__m.ViewContainerRef; + }, function($__m) { + ProtoViewRef = $__m.ProtoViewRef; + }, function($__m) { + isBlank = $__m.isBlank; + }], + execute: function() { + NgIf = (function() { + function NgIf(viewContainer, protoViewRef) { + this.viewContainer = viewContainer; + this.prevCondition = null; + this.protoViewRef = protoViewRef; + } + return ($traceurRuntime.createClass)(NgIf, {set ngIf(newCondition) { + if (newCondition && (isBlank(this.prevCondition) || !this.prevCondition)) { + this.prevCondition = true; + this.viewContainer.create(this.protoViewRef); + } else if (!newCondition && (isBlank(this.prevCondition) || this.prevCondition)) { + this.prevCondition = false; + this.viewContainer.clear(); } - } - }, {}); + }}, {}); }()); - $__export("FormBuilder", FormBuilder); - Object.defineProperty(FormBuilder.prototype.control, "parameters", {get: function() { - return [[], [Function]]; + $__export("NgIf", NgIf); + Object.defineProperty(NgIf, "annotations", {get: function() { + return [new Directive({ + selector: '[ng-if]', + properties: {'ngIf': 'ngIf'} + })]; }}); - Object.defineProperty(FormBuilder.prototype.array, "parameters", {get: function() { - return [[List], [Function]]; + Object.defineProperty(NgIf, "parameters", {get: function() { + return [[ViewContainerRef], [ProtoViewRef]]; }}); } }; }); -System.register("rtts_assert/rtts_assert", ["rtts_assert/src/rtts_assert"], function($__export) { +System.register("angular2/src/directives/ng_non_bindable", ["angular2/src/core/annotations_impl/annotations"], function($__export) { "use strict"; - var __moduleName = "rtts_assert/rtts_assert"; - var $__exportNames = {}; + var __moduleName = "angular2/src/directives/ng_non_bindable"; + var Directive, + NgNonBindable; return { setters: [function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); + Directive = $__m.Directive; }], - execute: function() {} + execute: function() { + NgNonBindable = (function() { + function NgNonBindable() {} + return ($traceurRuntime.createClass)(NgNonBindable, {}, {}); + }()); + $__export("NgNonBindable", NgNonBindable); + Object.defineProperty(NgNonBindable, "annotations", {get: function() { + return [new Directive({ + selector: '[ng-non-bindable]', + compileChildren: false + })]; + }}); + } }; }); -System.register("angular2/src/reflection/reflector", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/reflection/types"], function($__export) { +System.register("angular2/src/directives/ng_switch", ["angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/view_ref", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/core/annotations_impl/visibility"], function($__export) { "use strict"; - var __moduleName = "angular2/src/reflection/reflector"; - var assert, - Type, + var __moduleName = "angular2/src/directives/ng_switch"; + var Directive, + ViewContainerRef, + ProtoViewRef, isPresent, - stringify, - BaseException, - List, + isBlank, + normalizeBlank, ListWrapper, - Map, + List, MapWrapper, - StringMapWrapper, - SetterFn, - GetterFn, - MethodFn, - Reflector; - function _mergeMaps(target, config) { - StringMapWrapper.forEach(config, (function(v, k) { - return MapWrapper.set(target, k, v); - })); - } + Map, + Parent, + SwitchView, + NgSwitch, + NgSwitchWhen, + NgSwitchDefault, + _whenDefault; return { setters: [function($__m) { - assert = $__m.assert; + Directive = $__m.Directive; + }, function($__m) { + ViewContainerRef = $__m.ViewContainerRef; + }, function($__m) { + ProtoViewRef = $__m.ProtoViewRef; }, function($__m) { - Type = $__m.Type; isPresent = $__m.isPresent; - stringify = $__m.stringify; - BaseException = $__m.BaseException; + isBlank = $__m.isBlank; + normalizeBlank = $__m.normalizeBlank; }, function($__m) { - List = $__m.List; ListWrapper = $__m.ListWrapper; - Map = $__m.Map; + List = $__m.List; MapWrapper = $__m.MapWrapper; - StringMapWrapper = $__m.StringMapWrapper; + Map = $__m.Map; }, function($__m) { - SetterFn = $__m.SetterFn; - GetterFn = $__m.GetterFn; - MethodFn = $__m.MethodFn; - $__export("SetterFn", $__m.SetterFn); - $__export("GetterFn", $__m.GetterFn); - $__export("MethodFn", $__m.MethodFn); + Parent = $__m.Parent; }], execute: function() { - Reflector = (function() { - function Reflector(reflectionCapabilities) { - this._typeInfo = MapWrapper.create(); - this._getters = MapWrapper.create(); - this._setters = MapWrapper.create(); - this._methods = MapWrapper.create(); - this.reflectionCapabilities = reflectionCapabilities; + SwitchView = (function() { + function SwitchView(viewContainerRef, protoViewRef) { + this._protoViewRef = protoViewRef; + this._viewContainerRef = viewContainerRef; } - return ($traceurRuntime.createClass)(Reflector, { - registerType: function(type, typeInfo) { - MapWrapper.set(this._typeInfo, type, typeInfo); - }, - registerGetters: function(getters) { - _mergeMaps(this._getters, getters); - }, - registerSetters: function(setters) { - _mergeMaps(this._setters, setters); - }, - registerMethods: function(methods) { - _mergeMaps(this._methods, methods); + return ($traceurRuntime.createClass)(SwitchView, { + create: function() { + this._viewContainerRef.create(this._protoViewRef); }, - factory: function(type) { - assert.argumentTypes(type, Type); - if (MapWrapper.contains(this._typeInfo, type)) { - return assert.returnType((MapWrapper.get(this._typeInfo, type)["factory"]), Function); - } else { - return assert.returnType((this.reflectionCapabilities.factory(type)), Function); + destroy: function() { + this._viewContainerRef.clear(); + } + }, {}); + }()); + Object.defineProperty(SwitchView, "parameters", {get: function() { + return [[ViewContainerRef], [ProtoViewRef]]; + }}); + NgSwitch = (function() { + function NgSwitch() { + this._valueViews = MapWrapper.create(); + this._activeViews = ListWrapper.create(); + this._useDefault = false; + } + return ($traceurRuntime.createClass)(NgSwitch, { + set ngSwitch(value) { + this._emptyAllActiveViews(); + this._useDefault = false; + var views = MapWrapper.get(this._valueViews, value); + if (isBlank(views)) { + this._useDefault = true; + views = normalizeBlank(MapWrapper.get(this._valueViews, _whenDefault)); } + this._activateViews(views); + this._switchValue = value; }, - parameters: function(typeOfFunc) { - if (MapWrapper.contains(this._typeInfo, typeOfFunc)) { - return assert.returnType((MapWrapper.get(this._typeInfo, typeOfFunc)["parameters"]), List); - } else { - return assert.returnType((this.reflectionCapabilities.parameters(typeOfFunc)), List); + _onWhenValueChanged: function(oldWhen, newWhen, view) { + this._deregisterView(oldWhen, view); + this._registerView(newWhen, view); + if (oldWhen === this._switchValue) { + view.destroy(); + ListWrapper.remove(this._activeViews, view); + } else if (newWhen === this._switchValue) { + if (this._useDefault) { + this._useDefault = false; + this._emptyAllActiveViews(); + } + view.create(); + ListWrapper.push(this._activeViews, view); + } + if (this._activeViews.length === 0 && !this._useDefault) { + this._useDefault = true; + this._activateViews(MapWrapper.get(this._valueViews, _whenDefault)); } }, - annotations: function(typeOfFunc) { - if (MapWrapper.contains(this._typeInfo, typeOfFunc)) { - return assert.returnType((MapWrapper.get(this._typeInfo, typeOfFunc)["annotations"]), List); - } else { - return assert.returnType((this.reflectionCapabilities.annotations(typeOfFunc)), List); + _emptyAllActiveViews: function() { + var activeContainers = this._activeViews; + for (var i = 0; i < activeContainers.length; i++) { + activeContainers[i].destroy(); } + this._activeViews = ListWrapper.create(); }, - getter: function(name) { - assert.argumentTypes(name, assert.type.string); - if (MapWrapper.contains(this._getters, name)) { - return assert.returnType((MapWrapper.get(this._getters, name)), GetterFn); - } else { - return assert.returnType((this.reflectionCapabilities.getter(name)), GetterFn); + _activateViews: function(views) { + if (isPresent(views)) { + for (var i = 0; i < views.length; i++) { + views[i].create(); + } + this._activeViews = views; } }, - setter: function(name) { - assert.argumentTypes(name, assert.type.string); - if (MapWrapper.contains(this._setters, name)) { - return assert.returnType((MapWrapper.get(this._setters, name)), SetterFn); - } else { - return assert.returnType((this.reflectionCapabilities.setter(name)), SetterFn); + _registerView: function(value, view) { + var views = MapWrapper.get(this._valueViews, value); + if (isBlank(views)) { + views = ListWrapper.create(); + MapWrapper.set(this._valueViews, value, views); } + ListWrapper.push(views, view); }, - method: function(name) { - assert.argumentTypes(name, assert.type.string); - if (MapWrapper.contains(this._methods, name)) { - return assert.returnType((MapWrapper.get(this._methods, name)), MethodFn); + _deregisterView: function(value, view) { + if (value == _whenDefault) + return ; + var views = MapWrapper.get(this._valueViews, value); + if (views.length == 1) { + MapWrapper.delete(this._valueViews, value); } else { - return assert.returnType((this.reflectionCapabilities.method(name)), MethodFn); + ListWrapper.remove(views, view); } } }, {}); }()); - $__export("Reflector", Reflector); - Object.defineProperty(Reflector.prototype.factory, "parameters", {get: function() { - return [[Type]]; + $__export("NgSwitch", NgSwitch); + Object.defineProperty(NgSwitch, "annotations", {get: function() { + return [new Directive({ + selector: '[ng-switch]', + properties: {'ngSwitch': 'ngSwitch'} + })]; }}); - Object.defineProperty(Reflector.prototype.getter, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(NgSwitch.prototype._onWhenValueChanged, "parameters", {get: function() { + return [[], [], [SwitchView]]; }}); - Object.defineProperty(Reflector.prototype.setter, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(NgSwitch.prototype._activateViews, "parameters", {get: function() { + return [[assert.genericType(List, SwitchView)]]; }}); - Object.defineProperty(Reflector.prototype.method, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(NgSwitch.prototype._registerView, "parameters", {get: function() { + return [[], [SwitchView]]; + }}); + Object.defineProperty(NgSwitch.prototype._deregisterView, "parameters", {get: function() { + return [[], [SwitchView]]; + }}); + NgSwitchWhen = (function() { + function NgSwitchWhen(viewContainer, protoViewRef, sswitch) { + this._value = _whenDefault; + this._switch = sswitch; + this._view = new SwitchView(viewContainer, protoViewRef); + } + return ($traceurRuntime.createClass)(NgSwitchWhen, { + onDestroy: function() { + this._switch; + }, + set ngSwitchWhen(value) { + this._switch._onWhenValueChanged(this._value, value, this._view); + this._value = value; + } + }, {}); + }()); + $__export("NgSwitchWhen", NgSwitchWhen); + Object.defineProperty(NgSwitchWhen, "annotations", {get: function() { + return [new Directive({ + selector: '[ng-switch-when]', + properties: {'ngSwitchWhen': 'ngSwitchWhen'} + })]; + }}); + Object.defineProperty(NgSwitchWhen, "parameters", {get: function() { + return [[ViewContainerRef], [ProtoViewRef], [NgSwitch, new Parent()]]; + }}); + NgSwitchDefault = (function() { + function NgSwitchDefault(viewContainer, protoViewRef, sswitch) { + sswitch._registerView(_whenDefault, new SwitchView(viewContainer, protoViewRef)); + } + return ($traceurRuntime.createClass)(NgSwitchDefault, {}, {}); + }()); + $__export("NgSwitchDefault", NgSwitchDefault); + Object.defineProperty(NgSwitchDefault, "annotations", {get: function() { + return [new Directive({selector: '[ng-switch-default]'})]; + }}); + Object.defineProperty(NgSwitchDefault, "parameters", {get: function() { + return [[ViewContainerRef], [ProtoViewRef], [NgSwitch, new Parent()]]; + }}); + _whenDefault = new Object(); + } + }; +}); + +System.register("angular2/src/directives/class", ["angular2/src/core/annotations_impl/annotations", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/core/compiler/element_ref"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/directives/class"; + var Directive, + isPresent, + DOM, + ElementRef, + CSSClass; + return { + setters: [function($__m) { + Directive = $__m.Directive; + }, function($__m) { + isPresent = $__m.isPresent; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + ElementRef = $__m.ElementRef; + }], + execute: function() { + CSSClass = (function() { + function CSSClass(ngEl) { + this._domEl = ngEl.domElement; + } + return ($traceurRuntime.createClass)(CSSClass, { + _toggleClass: function(className, enabled) { + if (enabled) { + DOM.addClass(this._domEl, className); + } else { + DOM.removeClass(this._domEl, className); + } + }, + set iterableChanges(changes) { + var $__0 = this; + if (isPresent(changes)) { + changes.forEachAddedItem((function(record) { + $__0._toggleClass(record.key, record.currentValue); + })); + changes.forEachChangedItem((function(record) { + $__0._toggleClass(record.key, record.currentValue); + })); + changes.forEachRemovedItem((function(record) { + if (record.previousValue) { + DOM.removeClass($__0._domEl, record.key); + } + })); + } + } + }, {}); + }()); + $__export("CSSClass", CSSClass); + Object.defineProperty(CSSClass, "annotations", {get: function() { + return [new Directive({ + selector: '[class]', + properties: {'iterableChanges': 'class | keyValDiff'} + })]; }}); - Object.defineProperty(_mergeMaps, "parameters", {get: function() { - return [[Map], []]; + Object.defineProperty(CSSClass, "parameters", {get: function() { + return [[ElementRef]]; }}); } }; }); -System.register("angular2/src/facade/async", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "rx/dist/rx.all"], function($__export) { +System.register("angular2/src/forms/validators", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/forms/model"], function($__export) { "use strict"; - var __moduleName = "angular2/src/facade/async"; - var assert, - int, - global, + var __moduleName = "angular2/src/forms/validators"; + var isBlank, isPresent, List, - Rx, - Promise, - PromiseWrapper, - ObservableWrapper, - Observable, - EventEmitter; + ListWrapper, + StringMapWrapper, + modelModule, + Validators; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - int = $__m.int; - global = $__m.global; + isBlank = $__m.isBlank; isPresent = $__m.isPresent; }, function($__m) { List = $__m.List; + ListWrapper = $__m.ListWrapper; + StringMapWrapper = $__m.StringMapWrapper; }, function($__m) { - Rx = $__m.default; + modelModule = $__m; }], execute: function() { - Promise = global.Promise; - $__export("Promise", Promise); - PromiseWrapper = (function() { - function PromiseWrapper() {} - return ($traceurRuntime.createClass)(PromiseWrapper, {}, { - resolve: function(obj) { - return assert.returnType((Promise.resolve(obj)), Promise); - }, - reject: function(obj) { - return assert.returnType((Promise.reject(obj)), Promise); - }, - catchError: function(promise, onError) { - assert.argumentTypes(promise, Promise, onError, Function); - return assert.returnType((promise.catch(onError)), Promise); - }, - all: function(promises) { - assert.argumentTypes(promises, List); - if (promises.length == 0) - return assert.returnType((Promise.resolve([])), Promise); - return assert.returnType((Promise.all(promises)), Promise); + Validators = (function() { + function Validators() {} + return ($traceurRuntime.createClass)(Validators, {}, { + required: function(c) { + return isBlank(c.value) || c.value == "" ? {"required": true} : null; }, - then: function(promise, success, rejection) { - assert.argumentTypes(promise, Promise, success, Function, rejection, Function); - return assert.returnType((promise.then(success, rejection)), Promise); + nullValidator: function(c) { + return null; }, - completer: function() { - var resolve; - var reject; - var p = new Promise(function(res, rej) { - resolve = res; - reject = rej; - }); - return { - promise: p, - resolve: resolve, - reject: reject + compose: function(validators) { + return function(c) { + var res = ListWrapper.reduce(validators, (function(res, validator) { + var errors = validator(c); + return isPresent(errors) ? StringMapWrapper.merge(res, errors) : res; + }), {}); + return StringMapWrapper.isEmpty(res) ? null : res; }; }, - setTimeout: function(fn, millis) { - assert.argumentTypes(fn, Function, millis, int); - global.setTimeout(fn, millis); - }, - isPromise: function(maybePromise) { - return assert.returnType((maybePromise instanceof Promise), assert.type.boolean); - } - }); - }()); - $__export("PromiseWrapper", PromiseWrapper); - Object.defineProperty(PromiseWrapper.catchError, "parameters", {get: function() { - return [[Promise], [Function]]; - }}); - Object.defineProperty(PromiseWrapper.all, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(PromiseWrapper.then, "parameters", {get: function() { - return [[Promise], [Function], [Function]]; - }}); - Object.defineProperty(PromiseWrapper.setTimeout, "parameters", {get: function() { - return [[Function], [int]]; - }}); - ObservableWrapper = (function() { - function ObservableWrapper() {} - return ($traceurRuntime.createClass)(ObservableWrapper, {}, { - subscribe: function(emitter, onNext) { - var onThrow = arguments[2] !== (void 0) ? arguments[2] : null; - var onReturn = arguments[3] !== (void 0) ? arguments[3] : null; - assert.argumentTypes(emitter, EventEmitter, onNext, assert.type.any, onThrow, assert.type.any, onReturn, assert.type.any); - return emitter.observer({ - next: onNext, - throw: onThrow, - return: onReturn - }); - }, - dispose: function(subscription) { - assert.argumentTypes(subscription, assert.type.any); - subscription.dispose(); - }, - isObservable: function(obs) { - return assert.returnType((obs instanceof Observable), assert.type.boolean); - }, - callNext: function(emitter, value) { - assert.argumentTypes(emitter, EventEmitter, value, assert.type.any); - emitter.next(value); + group: function(c) { + var res = {}; + StringMapWrapper.forEach(c.controls, (function(control, name) { + if (c.contains(name) && isPresent(control.errors)) { + Validators._mergeErrors(control, res); + } + })); + return StringMapWrapper.isEmpty(res) ? null : res; }, - callThrow: function(emitter, error) { - assert.argumentTypes(emitter, EventEmitter, error, assert.type.any); - emitter.throw(error); + array: function(c) { + var res = {}; + ListWrapper.forEach(c.controls, (function(control) { + if (isPresent(control.errors)) { + Validators._mergeErrors(control, res); + } + })); + return StringMapWrapper.isEmpty(res) ? null : res; }, - callReturn: function(emitter) { - assert.argumentTypes(emitter, EventEmitter); - emitter.return(); + _mergeErrors: function(control, res) { + StringMapWrapper.forEach(control.errors, (function(value, error) { + if (!StringMapWrapper.contains(res, error)) { + res[error] = []; + } + ListWrapper.push(res[error], control); + })); } }); }()); - $__export("ObservableWrapper", ObservableWrapper); - Object.defineProperty(ObservableWrapper.subscribe, "parameters", {get: function() { - return [[EventEmitter], [], [], []]; + $__export("Validators", Validators); + Object.defineProperty(Validators.required, "parameters", {get: function() { + return [[modelModule.Control]]; }}); - Object.defineProperty(ObservableWrapper.dispose, "parameters", {get: function() { + Object.defineProperty(Validators.nullValidator, "parameters", {get: function() { return [[assert.type.any]]; }}); - Object.defineProperty(ObservableWrapper.callNext, "parameters", {get: function() { - return [[EventEmitter], [assert.type.any]]; - }}); - Object.defineProperty(ObservableWrapper.callThrow, "parameters", {get: function() { - return [[EventEmitter], [assert.type.any]]; - }}); - Object.defineProperty(ObservableWrapper.callReturn, "parameters", {get: function() { - return [[EventEmitter]]; - }}); - Observable = (function() { - function Observable() {} - return ($traceurRuntime.createClass)(Observable, {observer: function(generator) { - assert.argumentTypes(generator, Function); - }}, {}); - }()); - $__export("Observable", Observable); - Object.defineProperty(Observable.prototype.observer, "parameters", {get: function() { - return [[Function]]; + Object.defineProperty(Validators.compose, "parameters", {get: function() { + return [[assert.genericType(List, Function)]]; }}); - EventEmitter = (function($__super) { - function EventEmitter() { - $traceurRuntime.superConstructor(EventEmitter).call(this); - this._subject = new Rx.Subject(); - } - return ($traceurRuntime.createClass)(EventEmitter, { - observer: function(generator) { - return this._subject.observeOn(Rx.Scheduler.immediate).subscribe((function(value) { - setTimeout((function() { - return generator.next(value); - })); - }), (function(error) { - return generator.throw ? generator.throw(error) : null; - }), (function() { - return generator.return ? generator.return() : null; - })); - }, - toRx: function() { - return assert.returnType((this._subject), Rx.Observable); - }, - next: function(value) { - this._subject.onNext(value); - }, - throw: function(error) { - this._subject.onError(error); - }, - return: function(value) { - this._subject.onCompleted(); - } - }, {}, $__super); - }(Observable)); - $__export("EventEmitter", EventEmitter); - } - }; -}); - -System.register("angular2/src/change_detection/directive_record", ["rtts_assert/rtts_assert", "angular2/src/change_detection/constants", "angular2/src/facade/lang"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/directive_record"; - var assert, - ON_PUSH, - StringWrapper, - DirectiveIndex, - DirectiveRecord; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - ON_PUSH = $__m.ON_PUSH; - }, function($__m) { - StringWrapper = $__m.StringWrapper; - }], - execute: function() { - DirectiveIndex = (function() { - function DirectiveIndex(elementIndex, directiveIndex) { - assert.argumentTypes(elementIndex, assert.type.number, directiveIndex, assert.type.number); - this.elementIndex = elementIndex; - this.directiveIndex = directiveIndex; - } - return ($traceurRuntime.createClass)(DirectiveIndex, {get name() { - return (this.elementIndex + "_" + this.directiveIndex); - }}, {}); - }()); - $__export("DirectiveIndex", DirectiveIndex); - Object.defineProperty(DirectiveIndex, "parameters", {get: function() { - return [[assert.type.number], [assert.type.number]]; + Object.defineProperty(Validators.group, "parameters", {get: function() { + return [[modelModule.ControlGroup]]; }}); - DirectiveRecord = (function() { - function DirectiveRecord(directiveIndex, callOnAllChangesDone, callOnChange, changeDetection) { - assert.argumentTypes(directiveIndex, DirectiveIndex, callOnAllChangesDone, assert.type.boolean, callOnChange, assert.type.boolean, changeDetection, assert.type.string); - this.directiveIndex = directiveIndex; - this.callOnAllChangesDone = callOnAllChangesDone; - this.callOnChange = callOnChange; - this.changeDetection = changeDetection; - } - return ($traceurRuntime.createClass)(DirectiveRecord, {isOnPushChangeDetection: function() { - return assert.returnType((StringWrapper.equals(this.changeDetection, ON_PUSH)), assert.type.boolean); - }}, {}); - }()); - $__export("DirectiveRecord", DirectiveRecord); - Object.defineProperty(DirectiveRecord, "parameters", {get: function() { - return [[DirectiveIndex], [assert.type.boolean], [assert.type.boolean], [assert.type.string]]; + Object.defineProperty(Validators.array, "parameters", {get: function() { + return [[modelModule.ControlArray]]; }}); } }; }); -System.register("angular2/src/change_detection/change_detection_util", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/proto_record", "angular2/src/change_detection/exceptions", "angular2/src/change_detection/pipes/pipe", "angular2/src/change_detection/constants"], function($__export) { +System.register("angular2/src/forms/directives", ["angular2/src/core/annotations_impl/annotations", "angular2/src/core/annotations_impl/visibility", "angular2/src/core/compiler/element_ref", "angular2/src/di/annotations_impl", "angular2/src/render/api", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/forms/model", "angular2/src/forms/validators"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/change_detection_util"; - var assert, + var __moduleName = "angular2/src/forms/directives"; + var Directive, + onChange, + Ancestor, + ElementRef, + Optional, + Renderer, isPresent, - isBlank, - BaseException, - Type, - List, + isString, + CONST_EXPR, ListWrapper, - MapWrapper, - StringMapWrapper, - ProtoRecord, - ExpressionChangedAfterItHasBeenChecked, - WrappedValue, - CHECK_ALWAYS, - CHECK_ONCE, - CHECKED, - DETACHED, - ON_PUSH, - uninitialized, - SimpleChange, - _simpleChangesIndex, - _simpleChanges, - ChangeDetectionUtil; - function _simpleChange(previousValue, currentValue) { - var index = _simpleChangesIndex++ % 20; - var s = _simpleChanges[index]; - s.previousValue = previousValue; - s.currentValue = currentValue; - return s; - } + ControlGroup, + Validators, + DefaultValueAccessor, + CheckboxControlValueAccessor, + ControlDirective, + ControlGroupDirective, + formDirectives; return { setters: [function($__m) { - assert = $__m.assert; + Directive = $__m.Directive; + onChange = $__m.onChange; }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - Type = $__m.Type; + Ancestor = $__m.Ancestor; }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - StringMapWrapper = $__m.StringMapWrapper; + ElementRef = $__m.ElementRef; }, function($__m) { - ProtoRecord = $__m.ProtoRecord; + Optional = $__m.Optional; }, function($__m) { - ExpressionChangedAfterItHasBeenChecked = $__m.ExpressionChangedAfterItHasBeenChecked; + Renderer = $__m.Renderer; }, function($__m) { - WrappedValue = $__m.WrappedValue; + isPresent = $__m.isPresent; + isString = $__m.isString; + CONST_EXPR = $__m.CONST_EXPR; }, function($__m) { - CHECK_ALWAYS = $__m.CHECK_ALWAYS; - CHECK_ONCE = $__m.CHECK_ONCE; - CHECKED = $__m.CHECKED; - DETACHED = $__m.DETACHED; - ON_PUSH = $__m.ON_PUSH; + ListWrapper = $__m.ListWrapper; + }, function($__m) { + ControlGroup = $__m.ControlGroup; + }, function($__m) { + Validators = $__m.Validators; }], execute: function() { - uninitialized = new Object(); - $__export("uninitialized", uninitialized); - SimpleChange = (function() { - function SimpleChange(previousValue, currentValue) { - assert.argumentTypes(previousValue, assert.type.any, currentValue, assert.type.any); - this.previousValue = previousValue; - this.currentValue = currentValue; + DefaultValueAccessor = (function() { + function DefaultValueAccessor() { + this.onChange = (function(_) {}); } - return ($traceurRuntime.createClass)(SimpleChange, {}, {}); + return ($traceurRuntime.createClass)(DefaultValueAccessor, {writeValue: function(value) { + this.value = value; + }}, {}); }()); - $__export("SimpleChange", SimpleChange); - Object.defineProperty(SimpleChange, "parameters", {get: function() { - return [[assert.type.any], [assert.type.any]]; + $__export("DefaultValueAccessor", DefaultValueAccessor); + Object.defineProperty(DefaultValueAccessor, "annotations", {get: function() { + return [new Directive({ + selector: '[control]', + hostListeners: { + 'change': 'onChange($event.target.value)', + 'input': 'onChange($event.target.value)' + }, + hostProperties: {'value': 'value'} + })]; }}); - _simpleChangesIndex = 0; - _simpleChanges = [new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null)]; - ChangeDetectionUtil = (function() { - function ChangeDetectionUtil() {} - return ($traceurRuntime.createClass)(ChangeDetectionUtil, {}, { - unitialized: function() { - return uninitialized; - }, - arrayFn0: function() { - return []; - }, - arrayFn1: function(a1) { - return [a1]; - }, - arrayFn2: function(a1, a2) { - return [a1, a2]; - }, - arrayFn3: function(a1, a2, a3) { - return [a1, a2, a3]; - }, - arrayFn4: function(a1, a2, a3, a4) { - return [a1, a2, a3, a4]; - }, - arrayFn5: function(a1, a2, a3, a4, a5) { - return [a1, a2, a3, a4, a5]; - }, - arrayFn6: function(a1, a2, a3, a4, a5, a6) { - return [a1, a2, a3, a4, a5, a6]; - }, - arrayFn7: function(a1, a2, a3, a4, a5, a6, a7) { - return [a1, a2, a3, a4, a5, a6, a7]; - }, - arrayFn8: function(a1, a2, a3, a4, a5, a6, a7, a8) { - return [a1, a2, a3, a4, a5, a6, a7, a8]; - }, - arrayFn9: function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { - return [a1, a2, a3, a4, a5, a6, a7, a8, a9]; - }, - operation_negate: function(value) { - return !value; - }, - operation_add: function(left, right) { - return left + right; - }, - operation_subtract: function(left, right) { - return left - right; - }, - operation_multiply: function(left, right) { - return left * right; - }, - operation_divide: function(left, right) { - return left / right; - }, - operation_remainder: function(left, right) { - return left % right; - }, - operation_equals: function(left, right) { - return left == right; - }, - operation_not_equals: function(left, right) { - return left != right; - }, - operation_less_then: function(left, right) { - return left < right; - }, - operation_greater_then: function(left, right) { - return left > right; - }, - operation_less_or_equals_then: function(left, right) { - return left <= right; - }, - operation_greater_or_equals_then: function(left, right) { - return left >= right; + CheckboxControlValueAccessor = (function() { + function CheckboxControlValueAccessor(cd, elementRef, renderer) { + this.onChange = (function(_) {}); + this._elementRef = elementRef; + this._renderer = renderer; + cd.valueAccessor = this; + } + return ($traceurRuntime.createClass)(CheckboxControlValueAccessor, {writeValue: function(value) { + this._renderer.setElementProperty(this._elementRef.parentView.render, this._elementRef.boundElementIndex, 'checked', value); + }}, {}); + }()); + $__export("CheckboxControlValueAccessor", CheckboxControlValueAccessor); + Object.defineProperty(CheckboxControlValueAccessor, "annotations", {get: function() { + return [new Directive({ + selector: 'input[type=checkbox][control]', + hostListeners: {'change': 'onChange($event.target.checked)'}, + hostProperties: {'checked': 'checked'} + })]; + }}); + Object.defineProperty(CheckboxControlValueAccessor, "parameters", {get: function() { + return [[ControlDirective], [ElementRef], [Renderer]]; + }}); + ControlDirective = (function() { + function ControlDirective(groupDirective, valueAccessor) { + this._groupDirective = groupDirective; + this.controlOrName = null; + this.valueAccessor = valueAccessor; + this.validator = Validators.nullValidator; + } + return ($traceurRuntime.createClass)(ControlDirective, { + onChange: function(_) { + this._initialize(); }, - operation_logical_and: function(left, right) { - return left && right; + _initialize: function() { + if (isPresent(this._groupDirective)) { + this._groupDirective.addDirective(this); + } + var c = this._control(); + c.validator = Validators.compose([c.validator, this.validator]); + this._updateDomValue(); + this._setUpUpdateControlValue(); }, - operation_logical_or: function(left, right) { - return left || right; + _updateDomValue: function() { + this.valueAccessor.writeValue(this._control().value); }, - cond: function(cond, trueVal, falseVal) { - return cond ? trueVal : falseVal; + _setUpUpdateControlValue: function() { + var $__0 = this; + this.valueAccessor.onChange = (function(newValue) { + return $__0._control().updateValue(newValue); + }); }, - mapFn: function(keys) { - function buildMap(values) { - var res = StringMapWrapper.create(); - for (var i = 0; i < keys.length; ++i) { - StringMapWrapper.set(res, keys[i], values[i]); - } - return res; - } - switch (keys.length) { - case 0: - return (function() { - return []; - }); - case 1: - return (function(a1) { - return buildMap([a1]); - }); - case 2: - return (function(a1, a2) { - return buildMap([a1, a2]); - }); - case 3: - return (function(a1, a2, a3) { - return buildMap([a1, a2, a3]); - }); - case 4: - return (function(a1, a2, a3, a4) { - return buildMap([a1, a2, a3, a4]); - }); - case 5: - return (function(a1, a2, a3, a4, a5) { - return buildMap([a1, a2, a3, a4, a5]); - }); - case 6: - return (function(a1, a2, a3, a4, a5, a6) { - return buildMap([a1, a2, a3, a4, a5, a6]); - }); - case 7: - return (function(a1, a2, a3, a4, a5, a6, a7) { - return buildMap([a1, a2, a3, a4, a5, a6, a7]); - }); - case 8: - return (function(a1, a2, a3, a4, a5, a6, a7, a8) { - return buildMap([a1, a2, a3, a4, a5, a6, a7, a8]); - }); - case 9: - return (function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { - return buildMap([a1, a2, a3, a4, a5, a6, a7, a8, a9]); - }); - default: - throw new BaseException("Does not support literal maps with more than 9 elements"); + _control: function() { + if (isString(this.controlOrName)) { + return this._groupDirective.findControl(this.controlOrName); + } else { + return this.controlOrName; } - }, - keyedAccess: function(obj, args) { - return obj[args[0]]; - }, - unwrapValue: function(value) { - assert.argumentTypes(value, assert.type.any); - if (value instanceof WrappedValue) { - return assert.returnType((value.wrapped), assert.type.any); + } + }, {}); + }()); + $__export("ControlDirective", ControlDirective); + Object.defineProperty(ControlDirective, "annotations", {get: function() { + return [new Directive({ + lifecycle: [onChange], + selector: '[control]', + properties: {'controlOrName': 'control'} + })]; + }}); + Object.defineProperty(ControlDirective, "parameters", {get: function() { + return [[ControlGroupDirective, new Optional(), new Ancestor()], [DefaultValueAccessor]]; + }}); + ControlGroupDirective = (function() { + function ControlGroupDirective(groupDirective) { + this._groupDirective = groupDirective; + this._directives = ListWrapper.create(); + } + return ($traceurRuntime.createClass)(ControlGroupDirective, { + set controlGroup(controlGroup) { + if (isString(controlGroup)) { + this._controlGroupName = controlGroup; } else { - return assert.returnType((value), assert.type.any); + this._controlGroup = controlGroup; } + this._updateDomValue(); }, - throwOnChange: function(proto, change) { - assert.argumentTypes(proto, ProtoRecord, change, assert.type.any); - throw new ExpressionChangedAfterItHasBeenChecked(proto, change); + _updateDomValue: function() { + ListWrapper.forEach(this._directives, (function(cd) { + return cd._updateDomValue(); + })); }, - changeDetectionMode: function(strategy) { - assert.argumentTypes(strategy, assert.type.string); - return strategy == ON_PUSH ? CHECK_ONCE : CHECK_ALWAYS; + addDirective: function(c) { + ListWrapper.push(this._directives, c); }, - simpleChange: function(previousValue, currentValue) { - assert.argumentTypes(previousValue, assert.type.any, currentValue, assert.type.any); - return assert.returnType((_simpleChange(previousValue, currentValue)), SimpleChange); + findControl: function(name) { + return this._getControlGroup().controls[name]; }, - addChange: function(changes, propertyName, change) { - assert.argumentTypes(changes, assert.type.any, propertyName, assert.type.string, change, assert.type.any); - if (isBlank(changes)) { - changes = {}; + _getControlGroup: function() { + if (isPresent(this._controlGroupName)) { + return this._groupDirective.findControl(this._controlGroupName); + } else { + return this._controlGroup; } - changes[propertyName] = change; - return changes; } - }); + }, {}); }()); - $__export("ChangeDetectionUtil", ChangeDetectionUtil); - Object.defineProperty(ChangeDetectionUtil.mapFn, "parameters", {get: function() { - return [[List]]; + $__export("ControlGroupDirective", ControlGroupDirective); + Object.defineProperty(ControlGroupDirective, "annotations", {get: function() { + return [new Directive({ + selector: '[control-group]', + properties: {'controlGroup': 'control-group'} + })]; }}); - Object.defineProperty(ChangeDetectionUtil.unwrapValue, "parameters", {get: function() { - return [[assert.type.any]]; + Object.defineProperty(ControlGroupDirective, "parameters", {get: function() { + return [[ControlGroupDirective, new Optional(), new Ancestor()]]; }}); - Object.defineProperty(ChangeDetectionUtil.throwOnChange, "parameters", {get: function() { - return [[ProtoRecord], []]; + Object.defineProperty(ControlGroupDirective.prototype.addDirective, "parameters", {get: function() { + return [[ControlDirective]]; }}); - Object.defineProperty(ChangeDetectionUtil.changeDetectionMode, "parameters", {get: function() { + Object.defineProperty(ControlGroupDirective.prototype.findControl, "parameters", {get: function() { return [[assert.type.string]]; }}); - Object.defineProperty(ChangeDetectionUtil.simpleChange, "parameters", {get: function() { - return [[assert.type.any], [assert.type.any]]; - }}); - Object.defineProperty(ChangeDetectionUtil.addChange, "parameters", {get: function() { - return [[], [assert.type.string], []]; - }}); + formDirectives = CONST_EXPR([ControlGroupDirective, ControlDirective, CheckboxControlValueAccessor, DefaultValueAccessor]); + $__export("formDirectives", formDirectives); } }; }); -System.register("angular2/src/change_detection/abstract_change_detector", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/change_detector_ref", "angular2/src/change_detection/interfaces", "angular2/src/change_detection/constants"], function($__export) { +System.register("angular2/src/forms/validator_directives", ["angular2/src/core/annotations_impl/annotations", "angular2/src/forms/validators", "angular2/src/forms/directives"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/abstract_change_detector"; - var assert, - isPresent, - List, - ListWrapper, - ChangeDetectorRef, - ChangeDetector, - CHECK_ALWAYS, - CHECK_ONCE, - CHECKED, - DETACHED, - ON_PUSH, - AbstractChangeDetector; + var __moduleName = "angular2/src/forms/validator_directives"; + var Directive, + Validators, + ControlDirective, + RequiredValidatorDirective; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - ChangeDetectorRef = $__m.ChangeDetectorRef; + Directive = $__m.Directive; }, function($__m) { - ChangeDetector = $__m.ChangeDetector; + Validators = $__m.Validators; }, function($__m) { - CHECK_ALWAYS = $__m.CHECK_ALWAYS; - CHECK_ONCE = $__m.CHECK_ONCE; - CHECKED = $__m.CHECKED; - DETACHED = $__m.DETACHED; - ON_PUSH = $__m.ON_PUSH; + ControlDirective = $__m.ControlDirective; }], execute: function() { - AbstractChangeDetector = (function($__super) { - function AbstractChangeDetector() { - $traceurRuntime.superConstructor(AbstractChangeDetector).call(this); - this.lightDomChildren = []; - this.shadowDomChildren = []; - this.ref = new ChangeDetectorRef(this); - this.mode = null; + RequiredValidatorDirective = (function() { + function RequiredValidatorDirective(c) { + c.validator = Validators.compose([c.validator, Validators.required]); } - return ($traceurRuntime.createClass)(AbstractChangeDetector, { - addChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); - ListWrapper.push(this.lightDomChildren, cd); - cd.parent = this; - }, - removeChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); - ListWrapper.remove(this.lightDomChildren, cd); - }, - addShadowDomChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); - ListWrapper.push(this.shadowDomChildren, cd); - cd.parent = this; - }, - removeShadowDomChild: function(cd) { - assert.argumentTypes(cd, ChangeDetector); - ListWrapper.remove(this.shadowDomChildren, cd); - }, - remove: function() { - this.parent.removeChild(this); - }, - detectChanges: function() { - this._detectChanges(false); - }, - checkNoChanges: function() { - this._detectChanges(true); - }, - _detectChanges: function(throwOnChange) { - assert.argumentTypes(throwOnChange, assert.type.boolean); - if (this.mode === DETACHED || this.mode === CHECKED) - return ; - this.detectChangesInRecords(throwOnChange); - this._detectChangesInLightDomChildren(throwOnChange); - this.callOnAllChangesDone(); - this._detectChangesInShadowDomChildren(throwOnChange); - if (this.mode === CHECK_ONCE) - this.mode = CHECKED; - }, - detectChangesInRecords: function(throwOnChange) { - assert.argumentTypes(throwOnChange, assert.type.boolean); - }, - callOnAllChangesDone: function() {}, - _detectChangesInLightDomChildren: function(throwOnChange) { - assert.argumentTypes(throwOnChange, assert.type.boolean); - var c = this.lightDomChildren; - for (var i = 0; i < c.length; ++i) { - c[i]._detectChanges(throwOnChange); - } - }, - _detectChangesInShadowDomChildren: function(throwOnChange) { - assert.argumentTypes(throwOnChange, assert.type.boolean); - var c = this.shadowDomChildren; - for (var i = 0; i < c.length; ++i) { - c[i]._detectChanges(throwOnChange); - } - }, - markAsCheckOnce: function() { - this.mode = CHECK_ONCE; - }, - markPathToRootAsCheckOnce: function() { - var c = this; - while (isPresent(c) && c.mode != DETACHED) { - if (c.mode === CHECKED) - c.mode = CHECK_ONCE; - c = c.parent; - } - } - }, {}, $__super); - }(ChangeDetector)); - $__export("AbstractChangeDetector", AbstractChangeDetector); - Object.defineProperty(AbstractChangeDetector.prototype.addChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(AbstractChangeDetector.prototype.removeChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(AbstractChangeDetector.prototype.addShadowDomChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(AbstractChangeDetector.prototype.removeShadowDomChild, "parameters", {get: function() { - return [[ChangeDetector]]; - }}); - Object.defineProperty(AbstractChangeDetector.prototype._detectChanges, "parameters", {get: function() { - return [[assert.type.boolean]]; - }}); - Object.defineProperty(AbstractChangeDetector.prototype.detectChangesInRecords, "parameters", {get: function() { - return [[assert.type.boolean]]; - }}); - Object.defineProperty(AbstractChangeDetector.prototype._detectChangesInLightDomChildren, "parameters", {get: function() { - return [[assert.type.boolean]]; + return ($traceurRuntime.createClass)(RequiredValidatorDirective, {}, {}); + }()); + $__export("RequiredValidatorDirective", RequiredValidatorDirective); + Object.defineProperty(RequiredValidatorDirective, "annotations", {get: function() { + return [new Directive({selector: '[required]'})]; }}); - Object.defineProperty(AbstractChangeDetector.prototype._detectChangesInShadowDomChildren, "parameters", {get: function() { - return [[assert.type.boolean]]; + Object.defineProperty(RequiredValidatorDirective, "parameters", {get: function() { + return [[ControlDirective]]; }}); } }; }); -System.register("angular2/src/change_detection/change_detection", ["rtts_assert/rtts_assert", "angular2/src/change_detection/proto_change_detector", "angular2/src/change_detection/pipes/pipe_registry", "angular2/src/change_detection/pipes/iterable_changes", "angular2/src/change_detection/pipes/keyvalue_changes", "angular2/src/change_detection/pipes/async_pipe", "angular2/src/change_detection/pipes/null_pipe", "angular2/src/change_detection/constants", "angular2/src/change_detection/interfaces", "angular2/di"], function($__export) { +System.register("angular2/src/forms/form_builder", ["angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/forms/model"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/change_detection"; - var assert, - DynamicProtoChangeDetector, - JitProtoChangeDetector, - PipeRegistry, - IterableChangesFactory, - KeyValueChangesFactory, - AsyncPipeFactory, - NullPipeFactory, - DEFAULT, - ChangeDetection, - ProtoChangeDetector, - Injectable, - keyValDiff, - iterableDiff, - async, - defaultPipes, - DynamicChangeDetection, - JitChangeDetection, - defaultPipeRegistry; + var __moduleName = "angular2/src/forms/form_builder"; + var StringMapWrapper, + ListWrapper, + List, + isPresent, + modelModule, + FormBuilder; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - DynamicProtoChangeDetector = $__m.DynamicProtoChangeDetector; - JitProtoChangeDetector = $__m.JitProtoChangeDetector; - }, function($__m) { - PipeRegistry = $__m.PipeRegistry; - }, function($__m) { - IterableChangesFactory = $__m.IterableChangesFactory; - }, function($__m) { - KeyValueChangesFactory = $__m.KeyValueChangesFactory; - }, function($__m) { - AsyncPipeFactory = $__m.AsyncPipeFactory; - }, function($__m) { - NullPipeFactory = $__m.NullPipeFactory; - }, function($__m) { - DEFAULT = $__m.DEFAULT; + StringMapWrapper = $__m.StringMapWrapper; + ListWrapper = $__m.ListWrapper; + List = $__m.List; }, function($__m) { - ChangeDetection = $__m.ChangeDetection; - ProtoChangeDetector = $__m.ProtoChangeDetector; + isPresent = $__m.isPresent; }, function($__m) { - Injectable = $__m.Injectable; + modelModule = $__m; }], execute: function() { - keyValDiff = [new KeyValueChangesFactory(), new NullPipeFactory()]; - $__export("keyValDiff", keyValDiff); - iterableDiff = [new IterableChangesFactory(), new NullPipeFactory()]; - $__export("iterableDiff", iterableDiff); - async = [new AsyncPipeFactory(), new NullPipeFactory()]; - $__export("async", async); - defaultPipes = { - "iterableDiff": iterableDiff, - "keyValDiff": keyValDiff, - "async": async - }; - $__export("defaultPipes", defaultPipes); - DynamicChangeDetection = (function($__super) { - function DynamicChangeDetection(registry) { - assert.argumentTypes(registry, PipeRegistry); - $traceurRuntime.superConstructor(DynamicChangeDetection).call(this); - this.registry = registry; - } - return ($traceurRuntime.createClass)(DynamicChangeDetection, {createProtoChangeDetector: function(name) { - var changeControlStrategy = arguments[1] !== (void 0) ? arguments[1] : DEFAULT; - assert.argumentTypes(name, assert.type.string, changeControlStrategy, assert.type.string); - return assert.returnType((new DynamicProtoChangeDetector(this.registry, changeControlStrategy)), ProtoChangeDetector); - }}, {}, $__super); - }(ChangeDetection)); - $__export("DynamicChangeDetection", DynamicChangeDetection); - Object.defineProperty(DynamicChangeDetection, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(DynamicChangeDetection, "parameters", {get: function() { - return [[PipeRegistry]]; - }}); - Object.defineProperty(DynamicChangeDetection.prototype.createProtoChangeDetector, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; - }}); - JitChangeDetection = (function($__super) { - function JitChangeDetection(registry) { - assert.argumentTypes(registry, PipeRegistry); - $traceurRuntime.superConstructor(JitChangeDetection).call(this); - this.registry = registry; - } - return ($traceurRuntime.createClass)(JitChangeDetection, {createProtoChangeDetector: function(name) { - var changeControlStrategy = arguments[1] !== (void 0) ? arguments[1] : DEFAULT; - assert.argumentTypes(name, assert.type.string, changeControlStrategy, assert.type.string); - return assert.returnType((new JitProtoChangeDetector(this.registry, changeControlStrategy)), ProtoChangeDetector); - }}, {}, $__super); - }(ChangeDetection)); - $__export("JitChangeDetection", JitChangeDetection); - Object.defineProperty(JitChangeDetection, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(JitChangeDetection, "parameters", {get: function() { - return [[PipeRegistry]]; + FormBuilder = (function() { + function FormBuilder() {} + return ($traceurRuntime.createClass)(FormBuilder, { + group: function(controlsConfig) { + var extra = arguments[1] !== (void 0) ? arguments[1] : null; + var controls = this._reduceControls(controlsConfig); + var optionals = isPresent(extra) ? StringMapWrapper.get(extra, "optionals") : null; + var validator = isPresent(extra) ? StringMapWrapper.get(extra, "validator") : null; + if (isPresent(validator)) { + return new modelModule.ControlGroup(controls, optionals, validator); + } else { + return new modelModule.ControlGroup(controls, optionals); + } + }, + control: function(value) { + var validator = arguments[1] !== (void 0) ? arguments[1] : null; + if (isPresent(validator)) { + return new modelModule.Control(value, validator); + } else { + return new modelModule.Control(value); + } + }, + array: function(controlsConfig) { + var validator = arguments[1] !== (void 0) ? arguments[1] : null; + var $__0 = this; + var controls = ListWrapper.map(controlsConfig, (function(c) { + return $__0._createControl(c); + })); + if (isPresent(validator)) { + return new modelModule.ControlArray(controls, validator); + } else { + return new modelModule.ControlArray(controls); + } + }, + _reduceControls: function(controlsConfig) { + var $__0 = this; + var controls = {}; + StringMapWrapper.forEach(controlsConfig, (function(controlConfig, controlName) { + controls[controlName] = $__0._createControl(controlConfig); + })); + return controls; + }, + _createControl: function(controlConfig) { + if (controlConfig instanceof modelModule.Control || controlConfig instanceof modelModule.ControlGroup || controlConfig instanceof modelModule.ControlArray) { + return controlConfig; + } else if (ListWrapper.isList(controlConfig)) { + var value = ListWrapper.get(controlConfig, 0); + var validator = controlConfig.length > 1 ? controlConfig[1] : null; + return this.control(value, validator); + } else { + return this.control(controlConfig); + } + } + }, {}); + }()); + $__export("FormBuilder", FormBuilder); + Object.defineProperty(FormBuilder.prototype.control, "parameters", {get: function() { + return [[], [Function]]; }}); - Object.defineProperty(JitChangeDetection.prototype.createProtoChangeDetector, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; + Object.defineProperty(FormBuilder.prototype.array, "parameters", {get: function() { + return [[List], [Function]]; }}); - defaultPipeRegistry = new PipeRegistry(defaultPipes); - $__export("defaultPipeRegistry", defaultPipeRegistry); } }; }); -System.register("angular2/src/core/annotations/visibility", ["angular2/src/core/annotations_impl/visibility"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/annotations/visibility"; - return { - setters: [function($__m) { - $__export("AncestorAnnotation", $__m.Ancestor); - $__export("ParentAnnotation", $__m.Parent); - }], - execute: function() {} - }; -}); - -System.register("angular2/src/core/annotations/view", ["angular2/src/core/annotations_impl/view"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/annotations/view"; - return { - setters: [function($__m) { - $__export("ViewAnnotation", $__m.View); - }], - execute: function() {} - }; -}); - -System.register("angular2/src/dom/browser_adapter", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/dom/generic_browser_adapter"], function($__export) { +System.register("angular2/src/change_detection/parser/ast", ["angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { "use strict"; - var __moduleName = "angular2/src/dom/browser_adapter"; - var assert, - List, - MapWrapper, + var __moduleName = "angular2/src/change_detection/parser/ast"; + var isPresent, + FunctionWrapper, + BaseException, ListWrapper, - isBlank, - isPresent, - setRootDomAdapter, - GenericBrowserDomAdapter, - _attrToPropMap, - DOM_KEY_LOCATION_NUMPAD, - _keyMap, - _chromeNumKeyPadMap, - BrowserDomAdapter; + StringMapWrapper, + __esModule, + AST, + EmptyExpr, + ImplicitReceiver, + Chain, + Conditional, + AccessMember, + KeyedAccess, + Pipe, + LiteralPrimitive, + LiteralArray, + LiteralMap, + Interpolation, + Binary, + PrefixNot, + Assignment, + MethodCall, + FunctionCall, + ASTWithSource, + TemplateBinding, + AstVisitor, + AstTransformer, + _evalListCache; + function evalList(context, locals, exps) { + var length = exps.length; + if (length > 10) { + throw new BaseException("Cannot have more than 10 argument"); + } + var result = _evalListCache[length]; + for (var i = 0; i < length; i++) { + result[i] = exps[i].eval(context, locals); + } + return result; + } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - List = $__m.List; - MapWrapper = $__m.MapWrapper; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - isBlank = $__m.isBlank; isPresent = $__m.isPresent; + FunctionWrapper = $__m.FunctionWrapper; + BaseException = $__m.BaseException; }, function($__m) { - setRootDomAdapter = $__m.setRootDomAdapter; - }, function($__m) { - GenericBrowserDomAdapter = $__m.GenericBrowserDomAdapter; + ListWrapper = $__m.ListWrapper; + StringMapWrapper = $__m.StringMapWrapper; }], execute: function() { - _attrToPropMap = { - 'innerHtml': 'innerHTML', - 'readonly': 'readOnly', - 'tabindex': 'tabIndex' - }; - DOM_KEY_LOCATION_NUMPAD = 3; - _keyMap = { - '\b': 'Backspace', - '\t': 'Tab', - '\x7F': 'Delete', - '\x1B': 'Escape', - 'Del': 'Delete', - 'Esc': 'Escape', - 'Left': 'ArrowLeft', - 'Right': 'ArrowRight', - 'Up': 'ArrowUp', - 'Down': 'ArrowDown', - 'Menu': 'ContextMenu', - 'Scroll': 'ScrollLock', - 'Win': 'OS' - }; - _chromeNumKeyPadMap = { - 'A': '1', - 'B': '2', - 'C': '3', - 'D': '4', - 'E': '5', - 'F': '6', - 'G': '7', - 'H': '8', - 'I': '9', - 'J': '*', - 'K': '+', - 'M': '-', - 'N': '.', - 'O': '/', - '\x60': '0', - '\x90': 'NumLock' - }; - BrowserDomAdapter = (function($__super) { - function BrowserDomAdapter() { - $traceurRuntime.superConstructor(BrowserDomAdapter).apply(this, arguments); - } - return ($traceurRuntime.createClass)(BrowserDomAdapter, { - get attrToPropMap() { - return _attrToPropMap; + __esModule = true; + $__export("__esModule", __esModule); + AST = (function() { + function AST() {} + return ($traceurRuntime.createClass)(AST, { + eval: function(context, locals) { + throw new BaseException("Not supported"); }, - query: function(selector) { - assert.argumentTypes(selector, assert.type.string); - return document.querySelector(selector); + get isAssignable() { + return false; }, - querySelector: function(el, selector) { - assert.argumentTypes(el, assert.type.any, selector, assert.type.string); - return assert.returnType((el.querySelector(selector)), Node); + assign: function(context, locals, value) { + throw new BaseException("Not supported"); }, - querySelectorAll: function(el, selector) { - assert.argumentTypes(el, assert.type.any, selector, assert.type.string); - return assert.returnType((el.querySelectorAll(selector)), NodeList); + visit: function(visitor) { + return null; }, - on: function(el, evt, listener) { - el.addEventListener(evt, listener, false); + toString: function() { + return "AST"; + } + }, {}); + }()); + $__export("AST", AST); + EmptyExpr = (function($__super) { + function EmptyExpr() { + $traceurRuntime.superConstructor(EmptyExpr).apply(this, arguments); + } + return ($traceurRuntime.createClass)(EmptyExpr, { + eval: function(context, locals) { + return null; }, - onAndCancel: function(el, evt, listener) { - el.addEventListener(evt, listener, false); - return assert.returnType(((function() { - el.removeEventListener(evt, listener, false); - })), Function); + visit: function(visitor) {} + }, {}, $__super); + }(AST)); + $__export("EmptyExpr", EmptyExpr); + ImplicitReceiver = (function($__super) { + function ImplicitReceiver() { + $traceurRuntime.superConstructor(ImplicitReceiver).apply(this, arguments); + } + return ($traceurRuntime.createClass)(ImplicitReceiver, { + eval: function(context, locals) { + return context; }, - dispatchEvent: function(el, evt) { - el.dispatchEvent(evt); + visit: function(visitor) { + return visitor.visitImplicitReceiver(this); + } + }, {}, $__super); + }(AST)); + $__export("ImplicitReceiver", ImplicitReceiver); + Chain = (function($__super) { + function Chain(expressions) { + $traceurRuntime.superConstructor(Chain).call(this); + this.expressions = expressions; + } + return ($traceurRuntime.createClass)(Chain, { + eval: function(context, locals) { + var result; + for (var i = 0; i < this.expressions.length; i++) { + var last = this.expressions[i].eval(context, locals); + if (isPresent(last)) + result = last; + } + return result; + }, + visit: function(visitor) { + return visitor.visitChain(this); + } + }, {}, $__super); + }(AST)); + $__export("Chain", Chain); + Conditional = (function($__super) { + function Conditional(condition, trueExp, falseExp) { + $traceurRuntime.superConstructor(Conditional).call(this); + this.condition = condition; + this.trueExp = trueExp; + this.falseExp = falseExp; + } + return ($traceurRuntime.createClass)(Conditional, { + eval: function(context, locals) { + if (this.condition.eval(context, locals)) { + return this.trueExp.eval(context, locals); + } else { + return this.falseExp.eval(context, locals); + } + }, + visit: function(visitor) { + return visitor.visitConditional(this); + } + }, {}, $__super); + }(AST)); + $__export("Conditional", Conditional); + AccessMember = (function($__super) { + function AccessMember(receiver, name, getter, setter) { + $traceurRuntime.superConstructor(AccessMember).call(this); + this.receiver = receiver; + this.name = name; + this.getter = getter; + this.setter = setter; + } + return ($traceurRuntime.createClass)(AccessMember, { + eval: function(context, locals) { + if (this.receiver instanceof ImplicitReceiver && isPresent(locals) && locals.contains(this.name)) { + return locals.get(this.name); + } else { + var evaluatedReceiver = this.receiver.eval(context, locals); + return this.getter(evaluatedReceiver); + } }, - createMouseEvent: function(eventType) { - var evt = new MouseEvent(eventType); - evt.initEvent(eventType, true, true); - return evt; + get isAssignable() { + return true; }, - createEvent: function(eventType) { - return new Event(eventType, true); + assign: function(context, locals, value) { + var evaluatedContext = this.receiver.eval(context, locals); + if (this.receiver instanceof ImplicitReceiver && isPresent(locals) && locals.contains(this.name)) { + throw new BaseException(("Cannot reassign a variable binding " + this.name)); + } else { + return this.setter(evaluatedContext, value); + } }, - getInnerHTML: function(el) { - return el.innerHTML; + visit: function(visitor) { + return visitor.visitAccessMember(this); + } + }, {}, $__super); + }(AST)); + $__export("AccessMember", AccessMember); + KeyedAccess = (function($__super) { + function KeyedAccess(obj, key) { + $traceurRuntime.superConstructor(KeyedAccess).call(this); + this.obj = obj; + this.key = key; + } + return ($traceurRuntime.createClass)(KeyedAccess, { + eval: function(context, locals) { + var obj = this.obj.eval(context, locals); + var key = this.key.eval(context, locals); + return obj[key]; }, - getOuterHTML: function(el) { - return el.outerHTML; + get isAssignable() { + return true; }, - nodeName: function(node) { - assert.argumentTypes(node, Node); - return assert.returnType((node.nodeName), assert.type.string); + assign: function(context, locals, value) { + var obj = this.obj.eval(context, locals); + var key = this.key.eval(context, locals); + obj[key] = value; + return value; }, - nodeValue: function(node) { - assert.argumentTypes(node, Node); - return assert.returnType((node.nodeValue), assert.type.string); + visit: function(visitor) { + return visitor.visitKeyedAccess(this); + } + }, {}, $__super); + }(AST)); + $__export("KeyedAccess", KeyedAccess); + Pipe = (function($__super) { + function Pipe(exp, name, args, inBinding) { + $traceurRuntime.superConstructor(Pipe).call(this); + this.exp = exp; + this.name = name; + this.args = args; + this.inBinding = inBinding; + } + return ($traceurRuntime.createClass)(Pipe, {visit: function(visitor) { + return visitor.visitPipe(this); + }}, {}, $__super); + }(AST)); + $__export("Pipe", Pipe); + LiteralPrimitive = (function($__super) { + function LiteralPrimitive(value) { + $traceurRuntime.superConstructor(LiteralPrimitive).call(this); + this.value = value; + } + return ($traceurRuntime.createClass)(LiteralPrimitive, { + eval: function(context, locals) { + return this.value; }, - type: function(node) { - assert.argumentTypes(node, Node); - return node.type; + visit: function(visitor) { + return visitor.visitLiteralPrimitive(this); + } + }, {}, $__super); + }(AST)); + $__export("LiteralPrimitive", LiteralPrimitive); + LiteralArray = (function($__super) { + function LiteralArray(expressions) { + $traceurRuntime.superConstructor(LiteralArray).call(this); + this.expressions = expressions; + } + return ($traceurRuntime.createClass)(LiteralArray, { + eval: function(context, locals) { + return ListWrapper.map(this.expressions, (function(e) { + return e.eval(context, locals); + })); }, - content: function(node) { - assert.argumentTypes(node, HTMLElement); - if (this.hasProperty(node, "content")) { - return assert.returnType((node.content), Node); - } else { - return assert.returnType((node), Node); + visit: function(visitor) { + return visitor.visitLiteralArray(this); + } + }, {}, $__super); + }(AST)); + $__export("LiteralArray", LiteralArray); + LiteralMap = (function($__super) { + function LiteralMap(keys, values) { + $traceurRuntime.superConstructor(LiteralMap).call(this); + this.keys = keys; + this.values = values; + } + return ($traceurRuntime.createClass)(LiteralMap, { + eval: function(context, locals) { + var res = StringMapWrapper.create(); + for (var i = 0; i < this.keys.length; ++i) { + StringMapWrapper.set(res, this.keys[i], this.values[i].eval(context, locals)); } + return res; }, - firstChild: function(el) { - return assert.returnType((el.firstChild), Node); + visit: function(visitor) { + return visitor.visitLiteralMap(this); + } + }, {}, $__super); + }(AST)); + $__export("LiteralMap", LiteralMap); + Interpolation = (function($__super) { + function Interpolation(strings, expressions) { + $traceurRuntime.superConstructor(Interpolation).call(this); + this.strings = strings; + this.expressions = expressions; + } + return ($traceurRuntime.createClass)(Interpolation, { + eval: function(context, locals) { + throw new BaseException("evaluating an Interpolation is not supported"); }, - nextSibling: function(el) { - return assert.returnType((el.nextSibling), Node); + visit: function(visitor) { + visitor.visitInterpolation(this); + } + }, {}, $__super); + }(AST)); + $__export("Interpolation", Interpolation); + Binary = (function($__super) { + function Binary(operation, left, right) { + $traceurRuntime.superConstructor(Binary).call(this); + this.operation = operation; + this.left = left; + this.right = right; + } + return ($traceurRuntime.createClass)(Binary, { + eval: function(context, locals) { + var left = this.left.eval(context, locals); + switch (this.operation) { + case '&&': + return left && this.right.eval(context, locals); + case '||': + return left || this.right.eval(context, locals); + } + var right = this.right.eval(context, locals); + switch (this.operation) { + case '+': + return left + right; + case '-': + return left - right; + case '*': + return left * right; + case '/': + return left / right; + case '%': + return left % right; + case '==': + return left == right; + case '!=': + return left != right; + case '===': + return left === right; + case '!==': + return left !== right; + case '<': + return left < right; + case '>': + return left > right; + case '<=': + return left <= right; + case '>=': + return left >= right; + case '^': + return left ^ right; + case '&': + return left & right; + } + throw 'Internal error [$operation] not handled'; }, - parentElement: function(el) { - return el.parentElement; + visit: function(visitor) { + return visitor.visitBinary(this); + } + }, {}, $__super); + }(AST)); + $__export("Binary", Binary); + PrefixNot = (function($__super) { + function PrefixNot(expression) { + $traceurRuntime.superConstructor(PrefixNot).call(this); + this.expression = expression; + } + return ($traceurRuntime.createClass)(PrefixNot, { + eval: function(context, locals) { + return !this.expression.eval(context, locals); }, - childNodes: function(el) { - return assert.returnType((el.childNodes), NodeList); + visit: function(visitor) { + return visitor.visitPrefixNot(this); + } + }, {}, $__super); + }(AST)); + $__export("PrefixNot", PrefixNot); + Assignment = (function($__super) { + function Assignment(target, value) { + $traceurRuntime.superConstructor(Assignment).call(this); + this.target = target; + this.value = value; + } + return ($traceurRuntime.createClass)(Assignment, { + eval: function(context, locals) { + return this.target.assign(context, locals, this.value.eval(context, locals)); }, - childNodesAsList: function(el) { - var childNodes = el.childNodes; - var res = ListWrapper.createFixedSize(childNodes.length); - for (var i = 0; i < childNodes.length; i++) { - res[i] = childNodes[i]; + visit: function(visitor) { + return visitor.visitAssignment(this); + } + }, {}, $__super); + }(AST)); + $__export("Assignment", Assignment); + MethodCall = (function($__super) { + function MethodCall(receiver, name, fn, args) { + $traceurRuntime.superConstructor(MethodCall).call(this); + this.receiver = receiver; + this.name = name; + this.fn = fn; + this.args = args; + } + return ($traceurRuntime.createClass)(MethodCall, { + eval: function(context, locals) { + var evaluatedArgs = evalList(context, locals, this.args); + if (this.receiver instanceof ImplicitReceiver && isPresent(locals) && locals.contains(this.name)) { + var fn = locals.get(this.name); + return FunctionWrapper.apply(fn, evaluatedArgs); + } else { + var evaluatedReceiver = this.receiver.eval(context, locals); + return this.fn(evaluatedReceiver, evaluatedArgs); } - return assert.returnType((res), List); }, - clearNodes: function(el) { - for (var i = 0; i < el.childNodes.length; i++) { - this.remove(el.childNodes[i]); + visit: function(visitor) { + return visitor.visitMethodCall(this); + } + }, {}, $__super); + }(AST)); + $__export("MethodCall", MethodCall); + FunctionCall = (function($__super) { + function FunctionCall(target, args) { + $traceurRuntime.superConstructor(FunctionCall).call(this); + this.target = target; + this.args = args; + } + return ($traceurRuntime.createClass)(FunctionCall, { + eval: function(context, locals) { + var obj = this.target.eval(context, locals); + if (!(obj instanceof Function)) { + throw new BaseException((obj + " is not a function")); } + return FunctionWrapper.apply(obj, evalList(context, locals, this.args)); }, - appendChild: function(el, node) { - el.appendChild(node); + visit: function(visitor) { + return visitor.visitFunctionCall(this); + } + }, {}, $__super); + }(AST)); + $__export("FunctionCall", FunctionCall); + ASTWithSource = (function($__super) { + function ASTWithSource(ast, source, location) { + $traceurRuntime.superConstructor(ASTWithSource).call(this); + this.ast = ast; + this.source = source; + this.location = location; + } + return ($traceurRuntime.createClass)(ASTWithSource, { + eval: function(context, locals) { + return this.ast.eval(context, locals); }, - removeChild: function(el, node) { - el.removeChild(node); + get isAssignable() { + return this.ast.isAssignable; }, - replaceChild: function(el, newChild, oldChild) { - assert.argumentTypes(el, Node, newChild, assert.type.any, oldChild, assert.type.any); - el.replaceChild(newChild, oldChild); + assign: function(context, locals, value) { + return this.ast.assign(context, locals, value); }, - remove: function(el) { - var parent = el.parentNode; - parent.removeChild(el); - return el; + visit: function(visitor) { + return this.ast.visit(visitor); }, - insertBefore: function(el, node) { - el.parentNode.insertBefore(node, el); + toString: function() { + return (this.source + " in " + this.location); + } + }, {}, $__super); + }(AST)); + $__export("ASTWithSource", ASTWithSource); + TemplateBinding = (function() { + function TemplateBinding(key, keyIsVar, name, expression) { + this.key = key; + this.keyIsVar = keyIsVar; + this.name = name; + this.expression = expression; + } + return ($traceurRuntime.createClass)(TemplateBinding, {}, {}); + }()); + $__export("TemplateBinding", TemplateBinding); + AstVisitor = (function() { + function AstVisitor() {} + return ($traceurRuntime.createClass)(AstVisitor, { + visitAccessMember: function(ast) {}, + visitAssignment: function(ast) {}, + visitBinary: function(ast) {}, + visitChain: function(ast) {}, + visitConditional: function(ast) {}, + visitPipe: function(ast) {}, + visitFunctionCall: function(ast) {}, + visitImplicitReceiver: function(ast) {}, + visitKeyedAccess: function(ast) {}, + visitLiteralArray: function(ast) {}, + visitLiteralMap: function(ast) {}, + visitLiteralPrimitive: function(ast) {}, + visitMethodCall: function(ast) {}, + visitPrefixNot: function(ast) {} + }, {}); + }()); + $__export("AstVisitor", AstVisitor); + AstTransformer = (function() { + function AstTransformer() {} + return ($traceurRuntime.createClass)(AstTransformer, { + visitImplicitReceiver: function(ast) { + return ast; }, - insertAllBefore: function(el, nodes) { - ListWrapper.forEach(nodes, (function(n) { - el.parentNode.insertBefore(n, el); - })); + visitInterpolation: function(ast) { + return new Interpolation(ast.strings, this.visitAll(ast.expressions)); }, - insertAfter: function(el, node) { - el.parentNode.insertBefore(node, el.nextSibling); + visitLiteralPrimitive: function(ast) { + return new LiteralPrimitive(ast.value); }, - setInnerHTML: function(el, value) { - el.innerHTML = value; + visitAccessMember: function(ast) { + return new AccessMember(ast.receiver.visit(this), ast.name, ast.getter, ast.setter); }, - getText: function(el) { - return el.textContent; + visitMethodCall: function(ast) { + return new MethodCall(ast.receiver.visit(this), ast.name, ast.fn, this.visitAll(ast.args)); }, - setText: function(el, value) { - assert.argumentTypes(el, assert.type.any, value, assert.type.string); - el.textContent = value; + visitFunctionCall: function(ast) { + return new FunctionCall(ast.target.visit(this), this.visitAll(ast.args)); }, - getValue: function(el) { - return el.value; + visitLiteralArray: function(ast) { + return new LiteralArray(this.visitAll(ast.expressions)); }, - setValue: function(el, value) { - assert.argumentTypes(el, assert.type.any, value, assert.type.string); - el.value = value; + visitLiteralMap: function(ast) { + return new LiteralMap(ast.keys, this.visitAll(ast.values)); }, - getChecked: function(el) { - return el.checked; + visitBinary: function(ast) { + return new Binary(ast.operation, ast.left.visit(this), ast.right.visit(this)); }, - setChecked: function(el, value) { - assert.argumentTypes(el, assert.type.any, value, assert.type.boolean); - el.checked = value; + visitPrefixNot: function(ast) { + return new PrefixNot(ast.expression.visit(this)); }, - createTemplate: function(html) { - var t = document.createElement('template'); - t.innerHTML = html; - return t; + visitConditional: function(ast) { + return new Conditional(ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this)); }, - createElement: function(tagName) { - var doc = arguments[1] !== (void 0) ? arguments[1] : document; - return doc.createElement(tagName); + visitPipe: function(ast) { + return new Pipe(ast.exp.visit(this), ast.name, this.visitAll(ast.args), ast.inBinding); }, - createTextNode: function(text) { - var doc = arguments[1] !== (void 0) ? arguments[1] : document; - assert.argumentTypes(text, assert.type.string, doc, assert.type.any); - return doc.createTextNode(text); + visitKeyedAccess: function(ast) { + return new KeyedAccess(ast.obj.visit(this), ast.key.visit(this)); }, - createScriptTag: function(attrName, attrValue) { - var doc = arguments[2] !== (void 0) ? arguments[2] : document; - assert.argumentTypes(attrName, assert.type.string, attrValue, assert.type.string, doc, assert.type.any); - var el = doc.createElement('SCRIPT'); - el.setAttribute(attrName, attrValue); - return el; + visitAll: function(asts) { + var res = ListWrapper.createFixedSize(asts.length); + for (var i = 0; i < asts.length; ++i) { + res[i] = asts[i].visit(this); + } + return res; + } + }, {}); + }()); + $__export("AstTransformer", AstTransformer); + _evalListCache = [[], [0], [0, 0], [0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]; + } + }; +}); + +System.register("angular2/src/di/annotations", ["angular2/src/di/annotations_impl"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/di/annotations"; + return { + setters: [function($__m) { + $__export("InjectAnnotation", $__m.Inject); + $__export("InjectPromiseAnnotation", $__m.InjectPromise); + $__export("InjectLazyAnnotation", $__m.InjectLazy); + $__export("OptionalAnnotation", $__m.Optional); + $__export("InjectableAnnotation", $__m.Injectable); + $__export("DependencyAnnotation", $__m.DependencyAnnotation); + }], + execute: function() {} + }; +}); + +System.register("angular2/src/reflection/reflector", ["angular2/src/facade/collection", "angular2/src/reflection/types"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/reflection/reflector"; + var MapWrapper, + StringMapWrapper, + __esModule, + Reflector; + function _mergeMaps(target, config) { + StringMapWrapper.forEach(config, (function(v, k) { + return MapWrapper.set(target, k, v); + })); + } + return { + setters: [function($__m) { + MapWrapper = $__m.MapWrapper; + StringMapWrapper = $__m.StringMapWrapper; + }, function($__m) { + $__export("SetterFn", $__m.SetterFn); + $__export("GetterFn", $__m.GetterFn); + $__export("MethodFn", $__m.MethodFn); + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + Reflector = (function() { + function Reflector(reflectionCapabilities) { + this._typeInfo = MapWrapper.create(); + this._getters = MapWrapper.create(); + this._setters = MapWrapper.create(); + this._methods = MapWrapper.create(); + this.reflectionCapabilities = reflectionCapabilities; + } + return ($traceurRuntime.createClass)(Reflector, { + registerType: function(type, typeInfo) { + MapWrapper.set(this._typeInfo, type, typeInfo); }, - createStyleElement: function(css) { - var doc = arguments[1] !== (void 0) ? arguments[1] : document; - assert.argumentTypes(css, assert.type.string, doc, assert.type.any); - var style = doc.createElement('STYLE'); - style.innerText = css; - return assert.returnType((style), HTMLStyleElement); + registerGetters: function(getters) { + _mergeMaps(this._getters, getters); }, - createShadowRoot: function(el) { - assert.argumentTypes(el, HTMLElement); - return assert.returnType((el.createShadowRoot()), ShadowRoot); + registerSetters: function(setters) { + _mergeMaps(this._setters, setters); }, - getShadowRoot: function(el) { - assert.argumentTypes(el, HTMLElement); - return assert.returnType((el.shadowRoot), ShadowRoot); + registerMethods: function(methods) { + _mergeMaps(this._methods, methods); }, - getHost: function(el) { - assert.argumentTypes(el, HTMLElement); - return assert.returnType((el.host), HTMLElement); + factory: function(type) { + if (MapWrapper.contains(this._typeInfo, type)) { + return MapWrapper.get(this._typeInfo, type)["factory"]; + } else { + return this.reflectionCapabilities.factory(type); + } }, - clone: function(node) { - assert.argumentTypes(node, Node); - return node.cloneNode(true); + parameters: function(typeOfFunc) { + if (MapWrapper.contains(this._typeInfo, typeOfFunc)) { + return MapWrapper.get(this._typeInfo, typeOfFunc)["parameters"]; + } else { + return this.reflectionCapabilities.parameters(typeOfFunc); + } }, - hasProperty: function(element, name) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string); - return name in element; + annotations: function(typeOfFunc) { + if (MapWrapper.contains(this._typeInfo, typeOfFunc)) { + return MapWrapper.get(this._typeInfo, typeOfFunc)["annotations"]; + } else { + return this.reflectionCapabilities.annotations(typeOfFunc); + } }, - getElementsByClassName: function(element, name) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string); - return element.getElementsByClassName(name); + getter: function(name) { + if (MapWrapper.contains(this._getters, name)) { + return MapWrapper.get(this._getters, name); + } else { + return this.reflectionCapabilities.getter(name); + } }, - getElementsByTagName: function(element, name) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string); - return element.getElementsByTagName(name); + setter: function(name) { + if (MapWrapper.contains(this._setters, name)) { + return MapWrapper.get(this._setters, name); + } else { + return this.reflectionCapabilities.setter(name); + } + }, + method: function(name) { + if (MapWrapper.contains(this._methods, name)) { + return MapWrapper.get(this._methods, name); + } else { + return this.reflectionCapabilities.method(name); + } + } + }, {}); + }()); + $__export("Reflector", Reflector); + } + }; +}); + +System.register("angular2/src/change_detection/interfaces", ["angular2/src/change_detection/constants"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/interfaces"; + var DEFAULT, + __esModule, + ProtoChangeDetector, + ChangeDetection, + ChangeDispatcher, + ChangeDetector; + return { + setters: [function($__m) { + DEFAULT = $__m.DEFAULT; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + ProtoChangeDetector = (function() { + function ProtoChangeDetector() {} + return ($traceurRuntime.createClass)(ProtoChangeDetector, {instantiate: function(dispatcher) { + return null; + }}, {}); + }()); + $__export("ProtoChangeDetector", ProtoChangeDetector); + ChangeDetection = (function() { + function ChangeDetection() {} + return ($traceurRuntime.createClass)(ChangeDetection, {createProtoChangeDetector: function(name, bindingRecords, variableBindings, directiveRecords) { + var changeControlStrategy = arguments[4] !== (void 0) ? arguments[4] : DEFAULT; + return null; + }}, {}); + }()); + $__export("ChangeDetection", ChangeDetection); + ChangeDispatcher = (function() { + function ChangeDispatcher() {} + return ($traceurRuntime.createClass)(ChangeDispatcher, {notifyOnBinding: function(bindingRecord, value) {}}, {}); + }()); + $__export("ChangeDispatcher", ChangeDispatcher); + ChangeDetector = (function() { + function ChangeDetector() {} + return ($traceurRuntime.createClass)(ChangeDetector, { + addChild: function(cd) {}, + addShadowDomChild: function(cd) {}, + removeChild: function(cd) {}, + removeShadowDomChild: function(cd) {}, + remove: function() {}, + hydrate: function(context, locals, directives) {}, + dehydrate: function() {}, + markPathToRootAsCheckOnce: function() {}, + detectChanges: function() {}, + checkNoChanges: function() {} + }, {}); + }()); + $__export("ChangeDetector", ChangeDetector); + } + }; +}); + +System.register("angular2/src/change_detection/change_detection_util", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/exceptions", "angular2/src/change_detection/pipes/pipe", "angular2/src/change_detection/constants"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/change_detection/change_detection_util"; + var isBlank, + BaseException, + StringMapWrapper, + ExpressionChangedAfterItHasBeenChecked, + WrappedValue, + CHECK_ALWAYS, + CHECK_ONCE, + ON_PUSH, + __esModule, + uninitialized, + SimpleChange, + _simpleChangesIndex, + _simpleChanges, + ChangeDetectionUtil; + function _simpleChange(previousValue, currentValue) { + var index = _simpleChangesIndex++ % 20; + var s = _simpleChanges[index]; + s.previousValue = previousValue; + s.currentValue = currentValue; + return s; + } + return { + setters: [function($__m) { + isBlank = $__m.isBlank; + BaseException = $__m.BaseException; + }, function($__m) { + StringMapWrapper = $__m.StringMapWrapper; + }, function($__m) { + ExpressionChangedAfterItHasBeenChecked = $__m.ExpressionChangedAfterItHasBeenChecked; + }, function($__m) { + WrappedValue = $__m.WrappedValue; + }, function($__m) { + CHECK_ALWAYS = $__m.CHECK_ALWAYS; + CHECK_ONCE = $__m.CHECK_ONCE; + ON_PUSH = $__m.ON_PUSH; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + uninitialized = new Object(); + $__export("uninitialized", uninitialized); + SimpleChange = (function() { + function SimpleChange(previousValue, currentValue) { + this.previousValue = previousValue; + this.currentValue = currentValue; + } + return ($traceurRuntime.createClass)(SimpleChange, {}, {}); + }()); + $__export("SimpleChange", SimpleChange); + _simpleChangesIndex = 0; + _simpleChanges = [new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null), new SimpleChange(null, null)]; + ChangeDetectionUtil = (function() { + function ChangeDetectionUtil() {} + return ($traceurRuntime.createClass)(ChangeDetectionUtil, {}, { + unitialized: function() { + return uninitialized; }, - classList: function(element) { - return assert.returnType((Array.prototype.slice.call(element.classList, 0)), List); + arrayFn0: function() { + return []; }, - addClass: function(element, classname) { - assert.argumentTypes(element, assert.type.any, classname, assert.type.string); - element.classList.add(classname); + arrayFn1: function(a1) { + return [a1]; }, - removeClass: function(element, classname) { - assert.argumentTypes(element, assert.type.any, classname, assert.type.string); - element.classList.remove(classname); + arrayFn2: function(a1, a2) { + return [a1, a2]; }, - hasClass: function(element, classname) { - assert.argumentTypes(element, assert.type.any, classname, assert.type.string); - return element.classList.contains(classname); + arrayFn3: function(a1, a2, a3) { + return [a1, a2, a3]; }, - setStyle: function(element, stylename, stylevalue) { - assert.argumentTypes(element, assert.type.any, stylename, assert.type.string, stylevalue, assert.type.string); - element.style[stylename] = stylevalue; + arrayFn4: function(a1, a2, a3, a4) { + return [a1, a2, a3, a4]; }, - removeStyle: function(element, stylename) { - assert.argumentTypes(element, assert.type.any, stylename, assert.type.string); - element.style[stylename] = null; + arrayFn5: function(a1, a2, a3, a4, a5) { + return [a1, a2, a3, a4, a5]; }, - getStyle: function(element, stylename) { - assert.argumentTypes(element, assert.type.any, stylename, assert.type.string); - return element.style[stylename]; + arrayFn6: function(a1, a2, a3, a4, a5, a6) { + return [a1, a2, a3, a4, a5, a6]; }, - tagName: function(element) { - return assert.returnType((element.tagName), assert.type.string); + arrayFn7: function(a1, a2, a3, a4, a5, a6, a7) { + return [a1, a2, a3, a4, a5, a6, a7]; }, - attributeMap: function(element) { - var res = MapWrapper.create(); - var elAttrs = element.attributes; - for (var i = 0; i < elAttrs.length; i++) { - var attrib = elAttrs[i]; - MapWrapper.set(res, attrib.name, attrib.value); - } - return res; + arrayFn8: function(a1, a2, a3, a4, a5, a6, a7, a8) { + return [a1, a2, a3, a4, a5, a6, a7, a8]; }, - getAttribute: function(element, attribute) { - assert.argumentTypes(element, assert.type.any, attribute, assert.type.string); - return element.getAttribute(attribute); + arrayFn9: function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return [a1, a2, a3, a4, a5, a6, a7, a8, a9]; }, - setAttribute: function(element, name, value) { - assert.argumentTypes(element, assert.type.any, name, assert.type.string, value, assert.type.string); - element.setAttribute(name, value); + operation_negate: function(value) { + return !value; }, - removeAttribute: function(element, attribute) { - assert.argumentTypes(element, assert.type.any, attribute, assert.type.string); - return element.removeAttribute(attribute); + operation_add: function(left, right) { + return left + right; }, - templateAwareRoot: function(el) { - return this.isTemplateElement(el) ? this.content(el) : el; + operation_subtract: function(left, right) { + return left - right; }, - createHtmlDocument: function() { - return document.implementation.createHTMLDocument('fakeTitle'); + operation_multiply: function(left, right) { + return left * right; }, - defaultDoc: function() { - return document; + operation_divide: function(left, right) { + return left / right; }, - getBoundingClientRect: function(el) { - return el.getBoundingClientRect(); + operation_remainder: function(left, right) { + return left % right; }, - getTitle: function() { - return document.title; + operation_equals: function(left, right) { + return left == right; }, - setTitle: function(newTitle) { - assert.argumentTypes(newTitle, assert.type.string); - document.title = newTitle; + operation_not_equals: function(left, right) { + return left != right; }, - elementMatches: function(n, selector) { - assert.argumentTypes(n, assert.type.any, selector, assert.type.string); - return assert.returnType((n instanceof HTMLElement && n.matches(selector)), assert.type.boolean); + operation_less_then: function(left, right) { + return left < right; }, - isTemplateElement: function(el) { - assert.argumentTypes(el, assert.type.any); - return assert.returnType((el instanceof HTMLElement && el.nodeName == "TEMPLATE"), assert.type.boolean); + operation_greater_then: function(left, right) { + return left > right; }, - isTextNode: function(node) { - assert.argumentTypes(node, Node); - return assert.returnType((node.nodeType === Node.TEXT_NODE), assert.type.boolean); + operation_less_or_equals_then: function(left, right) { + return left <= right; }, - isCommentNode: function(node) { - assert.argumentTypes(node, Node); - return assert.returnType((node.nodeType === Node.COMMENT_NODE), assert.type.boolean); + operation_greater_or_equals_then: function(left, right) { + return left >= right; }, - isElementNode: function(node) { - assert.argumentTypes(node, Node); - return assert.returnType((node.nodeType === Node.ELEMENT_NODE), assert.type.boolean); + operation_logical_and: function(left, right) { + return left && right; }, - hasShadowRoot: function(node) { - return assert.returnType((node instanceof HTMLElement && isPresent(node.shadowRoot)), assert.type.boolean); + operation_logical_or: function(left, right) { + return left || right; }, - isShadowRoot: function(node) { - return assert.returnType((node instanceof ShadowRoot), assert.type.boolean); + cond: function(cond, trueVal, falseVal) { + return cond ? trueVal : falseVal; }, - importIntoDoc: function(node) { - assert.argumentTypes(node, Node); - var result = document.importNode(node, true); - if (this.isTemplateElement(result) && !this.content(result).childNodes.length && this.content(node).childNodes.length) { - var childNodes = this.content(node).childNodes; - for (var i = 0; i < childNodes.length; ++i) { - this.content(result).appendChild(this.importIntoDoc(childNodes[i])); + mapFn: function(keys) { + function buildMap(values) { + var res = StringMapWrapper.create(); + for (var i = 0; i < keys.length; ++i) { + StringMapWrapper.set(res, keys[i], values[i]); } + return res; + } + switch (keys.length) { + case 0: + return (function() { + return []; + }); + case 1: + return (function(a1) { + return buildMap([a1]); + }); + case 2: + return (function(a1, a2) { + return buildMap([a1, a2]); + }); + case 3: + return (function(a1, a2, a3) { + return buildMap([a1, a2, a3]); + }); + case 4: + return (function(a1, a2, a3, a4) { + return buildMap([a1, a2, a3, a4]); + }); + case 5: + return (function(a1, a2, a3, a4, a5) { + return buildMap([a1, a2, a3, a4, a5]); + }); + case 6: + return (function(a1, a2, a3, a4, a5, a6) { + return buildMap([a1, a2, a3, a4, a5, a6]); + }); + case 7: + return (function(a1, a2, a3, a4, a5, a6, a7) { + return buildMap([a1, a2, a3, a4, a5, a6, a7]); + }); + case 8: + return (function(a1, a2, a3, a4, a5, a6, a7, a8) { + return buildMap([a1, a2, a3, a4, a5, a6, a7, a8]); + }); + case 9: + return (function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return buildMap([a1, a2, a3, a4, a5, a6, a7, a8, a9]); + }); + default: + throw new BaseException("Does not support literal maps with more than 9 elements"); } - return result; - }, - isPageRule: function(rule) { - return assert.returnType((rule.type === CSSRule.PAGE_RULE), assert.type.boolean); }, - isStyleRule: function(rule) { - return assert.returnType((rule.type === CSSRule.STYLE_RULE), assert.type.boolean); + keyedAccess: function(obj, args) { + return obj[args[0]]; }, - isMediaRule: function(rule) { - return assert.returnType((rule.type === CSSRule.MEDIA_RULE), assert.type.boolean); + unwrapValue: function(value) { + if (value instanceof WrappedValue) { + return value.wrapped; + } else { + return value; + } }, - isKeyframesRule: function(rule) { - return assert.returnType((rule.type === CSSRule.KEYFRAMES_RULE), assert.type.boolean); + throwOnChange: function(proto, change) { + throw new ExpressionChangedAfterItHasBeenChecked(proto, change); }, - getHref: function(el) { - assert.argumentTypes(el, Element); - return assert.returnType((el.href), assert.type.string); + changeDetectionMode: function(strategy) { + return strategy == ON_PUSH ? CHECK_ONCE : CHECK_ALWAYS; }, - getEventKey: function(event) { - var key = event.key; - if (isBlank(key)) { - key = event.keyIdentifier; - if (isBlank(key)) { - return assert.returnType(('Unidentified'), assert.type.string); - } - if (key.startsWith('U+')) { - key = String.fromCharCode(parseInt(key.substring(2), 16)); - if (event.location === DOM_KEY_LOCATION_NUMPAD && _chromeNumKeyPadMap.hasOwnProperty(key)) { - key = _chromeNumKeyPadMap[key]; - } - } - } - if (_keyMap.hasOwnProperty(key)) { - key = _keyMap[key]; - } - return assert.returnType((key), assert.type.string); + simpleChange: function(previousValue, currentValue) { + return _simpleChange(previousValue, currentValue); }, - getGlobalEventTarget: function(target) { - assert.argumentTypes(target, assert.type.string); - if (target == "window") { - return window; - } else if (target == "document") { - return document; - } else if (target == "body") { - return document.body; + addChange: function(changes, propertyName, change) { + if (isBlank(changes)) { + changes = {}; } + changes[propertyName] = change; + return changes; } - }, {makeCurrent: function() { - setRootDomAdapter(new BrowserDomAdapter()); - }}, $__super); - }(GenericBrowserDomAdapter)); - $__export("BrowserDomAdapter", BrowserDomAdapter); - Object.defineProperty(BrowserDomAdapter.prototype.query, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.querySelector, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.querySelectorAll, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.nodeName, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.nodeValue, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.type, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.content, "parameters", {get: function() { - return [[HTMLElement]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.replaceChild, "parameters", {get: function() { - return [[Node], [], []]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.setText, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.setValue, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.setChecked, "parameters", {get: function() { - return [[], [assert.type.boolean]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.createTextNode, "parameters", {get: function() { - return [[assert.type.string], []]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.createScriptTag, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.createStyleElement, "parameters", {get: function() { - return [[assert.type.string], []]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.createShadowRoot, "parameters", {get: function() { - return [[HTMLElement]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getShadowRoot, "parameters", {get: function() { - return [[HTMLElement]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getHost, "parameters", {get: function() { - return [[HTMLElement]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.clone, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.hasProperty, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getElementsByClassName, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getElementsByTagName, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.addClass, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.removeClass, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.hasClass, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.setStyle, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.removeStyle, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getStyle, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getAttribute, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.setAttribute, "parameters", {get: function() { - return [[], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.removeAttribute, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.setTitle, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.elementMatches, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.isTemplateElement, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.isTextNode, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.isCommentNode, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.isElementNode, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.importIntoDoc, "parameters", {get: function() { - return [[Node]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getHref, "parameters", {get: function() { - return [[Element]]; - }}); - Object.defineProperty(BrowserDomAdapter.prototype.getGlobalEventTarget, "parameters", {get: function() { - return [[assert.type.string]]; - }}); + }); + }()); + $__export("ChangeDetectionUtil", ChangeDetectionUtil); } }; }); -System.register("angular2/src/core/compiler/directive_metadata_reader", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/directive_metadata", "angular2/src/reflection/reflection"], function($__export) { +System.register("angular2/src/change_detection/abstract_change_detector", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/change_detector_ref", "angular2/src/change_detection/interfaces", "angular2/src/change_detection/constants"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/compiler/directive_metadata_reader"; - var assert, - Injectable, - Injector, - Type, - isPresent, - BaseException, - stringify, - Directive, - Component, - DirectiveMetadata, - reflector, - DirectiveMetadataReader; + var __moduleName = "angular2/src/change_detection/abstract_change_detector"; + var isPresent, + ListWrapper, + ChangeDetectorRef, + ChangeDetector, + CHECK_ONCE, + CHECKED, + DETACHED, + __esModule, + AbstractChangeDetector; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; - Injector = $__m.Injector; - }, function($__m) { - Type = $__m.Type; isPresent = $__m.isPresent; - BaseException = $__m.BaseException; - stringify = $__m.stringify; }, function($__m) { - Directive = $__m.Directive; - Component = $__m.Component; + ListWrapper = $__m.ListWrapper; }, function($__m) { - DirectiveMetadata = $__m.DirectiveMetadata; + ChangeDetectorRef = $__m.ChangeDetectorRef; }, function($__m) { - reflector = $__m.reflector; + ChangeDetector = $__m.ChangeDetector; + }, function($__m) { + CHECK_ONCE = $__m.CHECK_ONCE; + CHECKED = $__m.CHECKED; + DETACHED = $__m.DETACHED; }], execute: function() { - DirectiveMetadataReader = (function() { - function DirectiveMetadataReader() {} - return ($traceurRuntime.createClass)(DirectiveMetadataReader, {read: function(type) { - assert.argumentTypes(type, Type); - var annotations = reflector.annotations(type); - if (isPresent(annotations)) { - for (var i = 0; i < annotations.length; i++) { - var annotation = annotations[i]; - if (annotation instanceof Directive) { - var resolvedInjectables = null; - if (annotation instanceof Component && isPresent(annotation.injectables)) { - resolvedInjectables = Injector.resolve(annotation.injectables); - } - return assert.returnType((new DirectiveMetadata(type, annotation, resolvedInjectables)), DirectiveMetadata); - } - } + __esModule = true; + $__export("__esModule", __esModule); + AbstractChangeDetector = (function($__super) { + function AbstractChangeDetector() { + $traceurRuntime.superConstructor(AbstractChangeDetector).call(this); + this.lightDomChildren = []; + this.shadowDomChildren = []; + this.ref = new ChangeDetectorRef(this); + this.mode = null; + } + return ($traceurRuntime.createClass)(AbstractChangeDetector, { + addChild: function(cd) { + ListWrapper.push(this.lightDomChildren, cd); + cd.parent = this; + }, + removeChild: function(cd) { + ListWrapper.remove(this.lightDomChildren, cd); + }, + addShadowDomChild: function(cd) { + ListWrapper.push(this.shadowDomChildren, cd); + cd.parent = this; + }, + removeShadowDomChild: function(cd) { + ListWrapper.remove(this.shadowDomChildren, cd); + }, + remove: function() { + this.parent.removeChild(this); + }, + detectChanges: function() { + this._detectChanges(false); + }, + checkNoChanges: function() { + this._detectChanges(true); + }, + _detectChanges: function(throwOnChange) { + if (this.mode === DETACHED || this.mode === CHECKED) + return ; + this.detectChangesInRecords(throwOnChange); + this._detectChangesInLightDomChildren(throwOnChange); + this.callOnAllChangesDone(); + this._detectChangesInShadowDomChildren(throwOnChange); + if (this.mode === CHECK_ONCE) + this.mode = CHECKED; + }, + detectChangesInRecords: function(throwOnChange) {}, + callOnAllChangesDone: function() {}, + _detectChangesInLightDomChildren: function(throwOnChange) { + var c = this.lightDomChildren; + for (var i = 0; i < c.length; ++i) { + c[i]._detectChanges(throwOnChange); } - throw new BaseException(("No Directive annotation found on " + stringify(type))); - }}, {}); - }()); - $__export("DirectiveMetadataReader", DirectiveMetadataReader); - Object.defineProperty(DirectiveMetadataReader, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(DirectiveMetadataReader.prototype.read, "parameters", {get: function() { - return [[Type]]; - }}); + }, + _detectChangesInShadowDomChildren: function(throwOnChange) { + var c = this.shadowDomChildren; + for (var i = 0; i < c.length; ++i) { + c[i]._detectChanges(throwOnChange); + } + }, + markAsCheckOnce: function() { + this.mode = CHECK_ONCE; + }, + markPathToRootAsCheckOnce: function() { + var c = this; + while (isPresent(c) && c.mode != DETACHED) { + if (c.mode === CHECKED) + c.mode = CHECK_ONCE; + c = c.parent; + } + } + }, {}, $__super); + }(ChangeDetector)); + $__export("AbstractChangeDetector", AbstractChangeDetector); } }; }); -System.register("angular2/src/core/compiler/view_ref", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/core/compiler/view", "angular2/src/render/api"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/core/compiler/view_ref"; - var assert, - isPresent, - viewModule, - RenderViewRef, - ViewRef, - ProtoViewRef; - function internalView(viewRef) { - assert.argumentTypes(viewRef, ViewRef); - return viewRef._view; - } - function internalProtoView(protoViewRef) { - assert.argumentTypes(protoViewRef, ProtoViewRef); - return isPresent(protoViewRef) ? protoViewRef._protoView : null; - } - $__export("internalView", internalView); - $__export("internalProtoView", internalProtoView); +System.register("angular2/src/facade/async", ["angular2/src/facade/lang", "rx"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/facade/async"; + var __esModule, + global, + Rx, + Promise, + PromiseWrapper, + ObservableWrapper, + Observable, + EventEmitter; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - viewModule = $__m; + global = $__m.global; }, function($__m) { - RenderViewRef = $__m.RenderViewRef; + Rx = $__m; }], execute: function() { - Object.defineProperty(internalView, "parameters", {get: function() { - return [[ViewRef]]; - }}); - Object.defineProperty(internalProtoView, "parameters", {get: function() { - return [[ProtoViewRef]]; - }}); - ViewRef = (function() { - function ViewRef(view) { - assert.argumentTypes(view, viewModule.AppView); - this._view = view; - } - return ($traceurRuntime.createClass)(ViewRef, { - get render() { - return assert.returnType((this._view.render), RenderViewRef); + __esModule = true; + $__export("__esModule", __esModule); + Promise = global.Promise; + $__export("Promise", Promise); + PromiseWrapper = (function() { + function PromiseWrapper() {} + return ($traceurRuntime.createClass)(PromiseWrapper, {}, { + resolve: function(obj) { + return Promise.resolve(obj); }, - setLocal: function(contextName, value) { - assert.argumentTypes(contextName, assert.type.string, value, assert.type.any); - this._view.setLocal(contextName, value); + reject: function(obj) { + return Promise.reject(obj); + }, + catchError: function(promise, onError) { + return promise.catch(onError); + }, + all: function(promises) { + if (promises.length == 0) + return Promise.resolve([]); + return Promise.all(promises); + }, + then: function(promise, success, rejection) { + return promise.then(success, rejection); + }, + completer: function() { + var resolve; + var reject; + var p = new Promise(function(res, rej) { + resolve = res; + reject = rej; + }); + return { + promise: p, + resolve: resolve, + reject: reject + }; + }, + setTimeout: function(fn, millis) { + global.setTimeout(fn, millis); + }, + isPromise: function(maybePromise) { + return maybePromise instanceof Promise; } - }, {}); + }); }()); - $__export("ViewRef", ViewRef); - Object.defineProperty(ViewRef, "parameters", {get: function() { - return [[viewModule.AppView]]; - }}); - Object.defineProperty(ViewRef.prototype.setLocal, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any]]; - }}); - ProtoViewRef = (function() { - function ProtoViewRef(protoView) { - this._protoView = protoView; - } - return ($traceurRuntime.createClass)(ProtoViewRef, {}, {}); + $__export("PromiseWrapper", PromiseWrapper); + ObservableWrapper = (function() { + function ObservableWrapper() {} + return ($traceurRuntime.createClass)(ObservableWrapper, {}, { + subscribe: function(emitter, onNext) { + var onThrow = arguments[2] !== (void 0) ? arguments[2] : null; + var onReturn = arguments[3] !== (void 0) ? arguments[3] : null; + return emitter.observer({ + next: onNext, + throw: onThrow, + return: onReturn + }); + }, + isObservable: function(obs) { + return obs instanceof Observable; + }, + dispose: function(subscription) { + subscription.dispose(); + }, + callNext: function(emitter, value) { + emitter.next(value); + }, + callThrow: function(emitter, error) { + emitter.throw(error); + }, + callReturn: function(emitter) { + emitter.return(null); + } + }); }()); - $__export("ProtoViewRef", ProtoViewRef); + $__export("ObservableWrapper", ObservableWrapper); + Observable = (function() { + function Observable() {} + return ($traceurRuntime.createClass)(Observable, {observer: function(generator) { + return null; + }}, {}); + }()); + $__export("Observable", Observable); + EventEmitter = (function($__super) { + function EventEmitter() { + $traceurRuntime.superConstructor(EventEmitter).call(this); + if (Rx.hasOwnProperty('default')) { + this._subject = new Rx.default.Rx.Subject(); + this._immediateScheduler = Rx.default.Rx.Scheduler.immediate; + } else { + this._subject = new Rx.Subject(); + this._immediateScheduler = Rx.Scheduler.immediate; + } + } + return ($traceurRuntime.createClass)(EventEmitter, { + observer: function(generator) { + return this._subject.observeOn(this._immediateScheduler).subscribe((function(value) { + setTimeout((function() { + return generator.next(value); + })); + }), (function(error) { + return generator.throw ? generator.throw(error) : null; + }), (function() { + return generator.return ? generator.return() : null; + })); + }, + toRx: function() { + return this._subject; + }, + next: function(value) { + this._subject.onNext(value); + }, + throw: function(error) { + this._subject.onError(error); + }, + return: function(value) { + this._subject.onCompleted(); + } + }, {}, $__super); + }(Observable)); + $__export("EventEmitter", EventEmitter); } }; }); -System.register("angular2/src/render/dom/view/proto_view", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/render/dom/view/element_binder", "angular2/src/render/dom/util"], function($__export) { +System.register("angular2/src/core/annotations/visibility", ["angular2/src/core/annotations_impl/visibility"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/view/proto_view"; - var assert, - isPresent, - DOM, - List, - Map, - ListWrapper, - MapWrapper, - ElementBinder, - NG_BINDING_CLASS, - RenderProtoView; + var __moduleName = "angular2/src/core/annotations/visibility"; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - List = $__m.List; - Map = $__m.Map; - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - }, function($__m) { - ElementBinder = $__m.ElementBinder; - }, function($__m) { - NG_BINDING_CLASS = $__m.NG_BINDING_CLASS; + $__export("AncestorAnnotation", $__m.Ancestor); + $__export("ParentAnnotation", $__m.Parent); }], - execute: function() { - RenderProtoView = (function() { - function RenderProtoView($__1) { - var $__2 = $__1, - elementBinders = $__2.elementBinders, - element = $__2.element, - imperativeRendererId = $__2.imperativeRendererId; - this.element = element; - this.elementBinders = elementBinders; - this.imperativeRendererId = imperativeRendererId; - if (isPresent(imperativeRendererId)) { - this.rootBindingOffset = 0; - this.isTemplateElement = false; - } else { - this.isTemplateElement = DOM.isTemplateElement(this.element); - this.rootBindingOffset = (isPresent(this.element) && DOM.hasClass(this.element, NG_BINDING_CLASS)) ? 1 : 0; - } - } - return ($traceurRuntime.createClass)(RenderProtoView, {mergeChildComponentProtoViews: function(componentProtoViews) { - assert.argumentTypes(componentProtoViews, assert.genericType(List, RenderProtoView)); - var componentProtoViewIndex = 0; - for (var i = 0; i < this.elementBinders.length; i++) { - var eb = this.elementBinders[i]; - if (isPresent(eb.componentId)) { - eb.nestedProtoView = componentProtoViews[componentProtoViewIndex]; - componentProtoViewIndex++; - } - } - }}, {}); - }()); - $__export("RenderProtoView", RenderProtoView); - Object.defineProperty(RenderProtoView.prototype.mergeChildComponentProtoViews, "parameters", {get: function() { - return [[assert.genericType(List, RenderProtoView)]]; - }}); - } + execute: function() {} }; }); -System.register("angular2/src/render/dom/shadow_dom/light_dom", ["rtts_assert/rtts_assert", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/content_tag"], function($__export) { +System.register("angular2/src/core/annotations/view", ["angular2/src/core/annotations_impl/view"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/light_dom"; - var assert, - DOM, - List, - ListWrapper, - isBlank, - isPresent, - viewModule, - Content, - DestinationLightDom, - _Root, - LightDom; - function redistributeNodes(contents, nodes) { - for (var i = 0; i < contents.length; ++i) { - var content = contents[i]; - var select = content.select; - if (select.length === 0) { - content.insert(ListWrapper.clone(nodes)); - ListWrapper.clear(nodes); - } else { - var matchSelector = (function(n) { - return DOM.elementMatches(n, select); - }); - var matchingNodes = ListWrapper.filter(nodes, matchSelector); - content.insert(matchingNodes); - ListWrapper.removeAll(nodes, matchingNodes); - } - } - for (var i = 0; i < nodes.length; i++) { - var node = nodes[i]; - if (isPresent(node.parentNode)) { - DOM.remove(nodes[i]); - } - } - } + var __moduleName = "angular2/src/core/annotations/view"; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; + $__export("ViewAnnotation", $__m.View); + }], + execute: function() {} + }; +}); + +System.register("angular2/src/di/key", ["angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/di/type_literal"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/di/key"; + var MapWrapper, + stringify, + TypeLiteral, + Key, + KeyRegistry, + _globalKeyRegistry; + return { + setters: [function($__m) { + MapWrapper = $__m.MapWrapper; }, function($__m) { - viewModule = $__m; + stringify = $__m.stringify; }, function($__m) { - Content = $__m.Content; + TypeLiteral = $__m.TypeLiteral; + $__export("TypeLiteral", $__m.TypeLiteral); }], execute: function() { - DestinationLightDom = (function() { - function DestinationLightDom() {} - return ($traceurRuntime.createClass)(DestinationLightDom, {}, {}); - }()); - $__export("DestinationLightDom", DestinationLightDom); - _Root = (function() { - function _Root(node, boundElementIndex) { - this.node = node; - this.boundElementIndex = boundElementIndex; + Key = (function() { + function Key(token, id) { + this.token = token; + this.id = id; } - return ($traceurRuntime.createClass)(_Root, {}, {}); + return ($traceurRuntime.createClass)(Key, {get displayName() { + return stringify(this.token); + }}, { + get: function(token) { + return _globalKeyRegistry.get(token); + }, + get numberOfKeys() { + return _globalKeyRegistry.numberOfKeys; + } + }); }()); - LightDom = (function() { - function LightDom(lightDomView, shadowDomView, element) { - assert.argumentTypes(lightDomView, viewModule.RenderView, shadowDomView, viewModule.RenderView, element, assert.type.any); - this.lightDomView = lightDomView; - this.shadowDomView = shadowDomView; - this.nodes = DOM.childNodesAsList(element); - this.roots = null; + $__export("Key", Key); + KeyRegistry = (function() { + function KeyRegistry() { + this._allKeys = MapWrapper.create(); } - return ($traceurRuntime.createClass)(LightDom, { - redistribute: function() { - redistributeNodes(this.contentTags(), this.expandedDomNodes()); - }, - contentTags: function() { - return assert.returnType((this._collectAllContentTags(this.shadowDomView, [])), assert.genericType(List, Content)); - }, - _collectAllContentTags: function(view, acc) { - var $__0 = this; - assert.argumentTypes(view, viewModule.RenderView, acc, assert.genericType(List, Content)); - var contentTags = view.contentTags; - var vcs = view.viewContainers; - for (var i = 0; i < vcs.length; i++) { - var vc = vcs[i]; - var contentTag = contentTags[i]; - if (isPresent(contentTag)) { - ListWrapper.push(acc, contentTag); - } - if (isPresent(vc)) { - ListWrapper.forEach(vc.contentTagContainers(), (function(view) { - $__0._collectAllContentTags(view, acc); - })); - } + return ($traceurRuntime.createClass)(KeyRegistry, { + get: function(token) { + if (token instanceof Key) + return token; + var theToken = token; + if (token instanceof TypeLiteral) { + theToken = token.type; } - return assert.returnType((acc), assert.genericType(List, Content)); - }, - expandedDomNodes: function() { - var res = []; - var roots = this._roots(); - for (var i = 0; i < roots.length; ++i) { - var root = roots[i]; - if (isPresent(root.boundElementIndex)) { - var vc = this.lightDomView.viewContainers[root.boundElementIndex]; - var content = this.lightDomView.contentTags[root.boundElementIndex]; - if (isPresent(vc)) { - res = ListWrapper.concat(res, vc.nodes()); - } else if (isPresent(content)) { - res = ListWrapper.concat(res, content.nodes()); - } else { - ListWrapper.push(res, root.node); - } - } else { - ListWrapper.push(res, root.node); - } + token = theToken; + if (MapWrapper.contains(this._allKeys, token)) { + return MapWrapper.get(this._allKeys, token); } - return assert.returnType((res), List); + var newKey = new Key(token, Key.numberOfKeys); + MapWrapper.set(this._allKeys, token, newKey); + return newKey; }, - _roots: function() { - if (isPresent(this.roots)) - return this.roots; - var boundElements = this.lightDomView.boundElements; - this.roots = ListWrapper.map(this.nodes, (function(n) { - var boundElementIndex = null; - for (var i = 0; i < boundElements.length; i++) { - var boundEl = boundElements[i]; - if (isPresent(boundEl) && boundEl === n) { - boundElementIndex = i; - break; - } - } - return new _Root(n, boundElementIndex); - })); - return this.roots; + get numberOfKeys() { + return MapWrapper.size(this._allKeys); } }, {}); }()); - $__export("LightDom", LightDom); - Object.defineProperty(LightDom, "parameters", {get: function() { - return [[viewModule.RenderView], [viewModule.RenderView], []]; - }}); - Object.defineProperty(LightDom.prototype._collectAllContentTags, "parameters", {get: function() { - return [[viewModule.RenderView], [assert.genericType(List, Content)]]; - }}); - Object.defineProperty(redistributeNodes, "parameters", {get: function() { - return [[assert.genericType(List, Content)], [List]]; - }}); + $__export("KeyRegistry", KeyRegistry); + _globalKeyRegistry = new KeyRegistry(); } }; }); -System.register("angular2/src/render/dom/events/event_manager", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/core/zone/vm_turn_zone"], function($__export) { +System.register("angular2/src/dom/browser_adapter", ["angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/dom/generic_browser_adapter"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/events/event_manager"; - var assert, + var __moduleName = "angular2/src/dom/browser_adapter"; + var MapWrapper, + ListWrapper, isBlank, - BaseException, isPresent, - StringWrapper, - DOM, - List, - ListWrapper, - MapWrapper, - VmTurnZone, - BUBBLE_SYMBOL, - EventManager, - EventManagerPlugin, - DomEventsPlugin; + setRootDomAdapter, + GenericBrowserDomAdapter, + __esModule, + _attrToPropMap, + DOM_KEY_LOCATION_NUMPAD, + _keyMap, + _chromeNumKeyPadMap, + BrowserDomAdapter, + urlParsingNode; + function relativePath(url) { + if (isBlank(urlParsingNode)) { + urlParsingNode = document.createElement("a"); + } + urlParsingNode.setAttribute('href', url); + return (urlParsingNode.pathname.charAt(0) === '/') ? urlParsingNode.pathname : '/' + urlParsingNode.pathname; + } return { setters: [function($__m) { - assert = $__m.assert; + MapWrapper = $__m.MapWrapper; + ListWrapper = $__m.ListWrapper; }, function($__m) { isBlank = $__m.isBlank; - BaseException = $__m.BaseException; isPresent = $__m.isPresent; - StringWrapper = $__m.StringWrapper; - }, function($__m) { - DOM = $__m.DOM; }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; + setRootDomAdapter = $__m.setRootDomAdapter; }, function($__m) { - VmTurnZone = $__m.VmTurnZone; + GenericBrowserDomAdapter = $__m.GenericBrowserDomAdapter; }], execute: function() { - BUBBLE_SYMBOL = '^'; - EventManager = (function() { - function EventManager(plugins, zone) { - assert.argumentTypes(plugins, assert.genericType(List, EventManagerPlugin), zone, VmTurnZone); - this._zone = zone; - this._plugins = plugins; - for (var i = 0; i < plugins.length; i++) { - plugins[i].manager = this; - } + __esModule = true; + $__export("__esModule", __esModule); + _attrToPropMap = { + 'innerHtml': 'innerHTML', + 'readonly': 'readOnly', + 'tabindex': 'tabIndex' + }; + DOM_KEY_LOCATION_NUMPAD = 3; + _keyMap = { + '\b': 'Backspace', + '\t': 'Tab', + '\x7F': 'Delete', + '\x1B': 'Escape', + 'Del': 'Delete', + 'Esc': 'Escape', + 'Left': 'ArrowLeft', + 'Right': 'ArrowRight', + 'Up': 'ArrowUp', + 'Down': 'ArrowDown', + 'Menu': 'ContextMenu', + 'Scroll': 'ScrollLock', + 'Win': 'OS' + }; + _chromeNumKeyPadMap = { + 'A': '1', + 'B': '2', + 'C': '3', + 'D': '4', + 'E': '5', + 'F': '6', + 'G': '7', + 'H': '8', + 'I': '9', + 'J': '*', + 'K': '+', + 'M': '-', + 'N': '.', + 'O': '/', + '\x60': '0', + '\x90': 'NumLock' + }; + BrowserDomAdapter = (function($__super) { + function BrowserDomAdapter() { + $traceurRuntime.superConstructor(BrowserDomAdapter).apply(this, arguments); } - return ($traceurRuntime.createClass)(EventManager, { - addEventListener: function(element, eventName, handler) { - assert.argumentTypes(element, assert.type.any, eventName, assert.type.string, handler, Function); - var withoutBubbleSymbol = this._removeBubbleSymbol(eventName); - var plugin = this._findPluginFor(withoutBubbleSymbol); - plugin.addEventListener(element, withoutBubbleSymbol, handler, withoutBubbleSymbol != eventName); + return ($traceurRuntime.createClass)(BrowserDomAdapter, { + logError: function(error) { + window.console.error(error); + }, + get attrToPropMap() { + return _attrToPropMap; + }, + query: function(selector) { + return document.querySelector(selector); + }, + querySelector: function(el, selector) { + return el.querySelector(selector); + }, + querySelectorAll: function(el, selector) { + return el.querySelectorAll(selector); + }, + on: function(el, evt, listener) { + el.addEventListener(evt, listener, false); + }, + onAndCancel: function(el, evt, listener) { + el.addEventListener(evt, listener, false); + return (function() { + el.removeEventListener(evt, listener, false); + }); + }, + dispatchEvent: function(el, evt) { + el.dispatchEvent(evt); + }, + createMouseEvent: function(eventType) { + var evt = new MouseEvent(eventType); + evt.initEvent(eventType, true, true); + return evt; + }, + createEvent: function(eventType) { + return new Event(eventType, true); + }, + getInnerHTML: function(el) { + return el.innerHTML; + }, + getOuterHTML: function(el) { + return el.outerHTML; + }, + nodeName: function(node) { + return node.nodeName; + }, + nodeValue: function(node) { + return node.nodeValue; + }, + type: function(node) { + return node.type; + }, + content: function(node) { + if (this.hasProperty(node, "content")) { + return node.content; + } else { + return node; + } + }, + firstChild: function(el) { + return el.firstChild; + }, + nextSibling: function(el) { + return el.nextSibling; + }, + parentElement: function(el) { + return el.parentElement; + }, + childNodes: function(el) { + return el.childNodes; + }, + childNodesAsList: function(el) { + var childNodes = el.childNodes; + var res = ListWrapper.createFixedSize(childNodes.length); + for (var i = 0; i < childNodes.length; i++) { + res[i] = childNodes[i]; + } + return res; + }, + clearNodes: function(el) { + for (var i = 0; i < el.childNodes.length; i++) { + this.remove(el.childNodes[i]); + } + }, + appendChild: function(el, node) { + el.appendChild(node); + }, + removeChild: function(el, node) { + el.removeChild(node); }, - addGlobalEventListener: function(target, eventName, handler) { - assert.argumentTypes(target, assert.type.string, eventName, assert.type.string, handler, Function); - var withoutBubbleSymbol = this._removeBubbleSymbol(eventName); - var plugin = this._findPluginFor(withoutBubbleSymbol); - return assert.returnType((plugin.addGlobalEventListener(target, withoutBubbleSymbol, handler, withoutBubbleSymbol != eventName)), Function); + replaceChild: function(el, newChild, oldChild) { + el.replaceChild(newChild, oldChild); }, - getZone: function() { - return assert.returnType((this._zone), VmTurnZone); + remove: function(el) { + var parent = el.parentNode; + parent.removeChild(el); + return el; }, - _findPluginFor: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); - var plugins = this._plugins; - for (var i = 0; i < plugins.length; i++) { - var plugin = plugins[i]; - if (plugin.supports(eventName)) { - return assert.returnType((plugin), EventManagerPlugin); - } - } - throw new BaseException(("No event manager plugin found for event " + eventName)); + insertBefore: function(el, node) { + el.parentNode.insertBefore(node, el); }, - _removeBubbleSymbol: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); - return assert.returnType((eventName[0] == BUBBLE_SYMBOL ? StringWrapper.substring(eventName, 1) : eventName), assert.type.string); - } - }, {}); - }()); - $__export("EventManager", EventManager); - Object.defineProperty(EventManager, "parameters", {get: function() { - return [[assert.genericType(List, EventManagerPlugin)], [VmTurnZone]]; - }}); - Object.defineProperty(EventManager.prototype.addEventListener, "parameters", {get: function() { - return [[], [assert.type.string], [Function]]; - }}); - Object.defineProperty(EventManager.prototype.addGlobalEventListener, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [Function]]; - }}); - Object.defineProperty(EventManager.prototype._findPluginFor, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(EventManager.prototype._removeBubbleSymbol, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - EventManagerPlugin = (function() { - function EventManagerPlugin() {} - return ($traceurRuntime.createClass)(EventManagerPlugin, { - supports: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); - return assert.returnType((false), assert.type.boolean); + insertAllBefore: function(el, nodes) { + ListWrapper.forEach(nodes, (function(n) { + el.parentNode.insertBefore(n, el); + })); }, - addEventListener: function(element, eventName, handler, shouldSupportBubble) { - assert.argumentTypes(element, assert.type.any, eventName, assert.type.string, handler, Function, shouldSupportBubble, assert.type.boolean); - throw "not implemented"; + insertAfter: function(el, node) { + el.parentNode.insertBefore(node, el.nextSibling); }, - addGlobalEventListener: function(element, eventName, handler, shouldSupportBubble) { - assert.argumentTypes(element, assert.type.any, eventName, assert.type.string, handler, Function, shouldSupportBubble, assert.type.boolean); - throw "not implemented"; - } - }, {}); - }()); - $__export("EventManagerPlugin", EventManagerPlugin); - Object.defineProperty(EventManagerPlugin.prototype.supports, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(EventManagerPlugin.prototype.addEventListener, "parameters", {get: function() { - return [[], [assert.type.string], [Function], [assert.type.boolean]]; - }}); - Object.defineProperty(EventManagerPlugin.prototype.addGlobalEventListener, "parameters", {get: function() { - return [[], [assert.type.string], [Function], [assert.type.boolean]]; - }}); - DomEventsPlugin = (function($__super) { - function DomEventsPlugin() { - $traceurRuntime.superConstructor(DomEventsPlugin).apply(this, arguments); - } - return ($traceurRuntime.createClass)(DomEventsPlugin, { - supports: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); - return assert.returnType((true), assert.type.boolean); + setInnerHTML: function(el, value) { + el.innerHTML = value; }, - addEventListener: function(element, eventName, handler, shouldSupportBubble) { - assert.argumentTypes(element, assert.type.any, eventName, assert.type.string, handler, Function, shouldSupportBubble, assert.type.boolean); - var outsideHandler = this._getOutsideHandler(shouldSupportBubble, element, handler, this.manager._zone); - this.manager._zone.runOutsideAngular((function() { - DOM.on(element, eventName, outsideHandler); - })); + getText: function(el) { + return el.textContent; }, - addGlobalEventListener: function(target, eventName, handler, shouldSupportBubble) { - assert.argumentTypes(target, assert.type.string, eventName, assert.type.string, handler, Function, shouldSupportBubble, assert.type.boolean); - var element = DOM.getGlobalEventTarget(target); - var outsideHandler = this._getOutsideHandler(shouldSupportBubble, element, handler, this.manager._zone); - return assert.returnType((this.manager._zone.runOutsideAngular((function() { - return DOM.onAndCancel(element, eventName, outsideHandler); - }))), Function); + setText: function(el, value) { + el.textContent = value; }, - _getOutsideHandler: function(shouldSupportBubble, element, handler, zone) { - assert.argumentTypes(shouldSupportBubble, assert.type.boolean, element, assert.type.any, handler, Function, zone, VmTurnZone); - return shouldSupportBubble ? DomEventsPlugin.bubbleCallback(element, handler, zone) : DomEventsPlugin.sameElementCallback(element, handler, zone); - } - }, { - sameElementCallback: function(element, handler, zone) { - return (function(event) { - if (event.target === element) { - zone.run((function() { - return handler(event); - })); - } - }); + getValue: function(el) { + return el.value; }, - bubbleCallback: function(element, handler, zone) { - return (function(event) { - return zone.run((function() { - return handler(event); - })); - }); - } - }, $__super); - }(EventManagerPlugin)); - $__export("DomEventsPlugin", DomEventsPlugin); - Object.defineProperty(DomEventsPlugin.prototype.supports, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(DomEventsPlugin.prototype.addEventListener, "parameters", {get: function() { - return [[], [assert.type.string], [Function], [assert.type.boolean]]; - }}); - Object.defineProperty(DomEventsPlugin.prototype.addGlobalEventListener, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], [Function], [assert.type.boolean]]; - }}); - Object.defineProperty(DomEventsPlugin.prototype._getOutsideHandler, "parameters", {get: function() { - return [[assert.type.boolean], [], [Function], [VmTurnZone]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/view/proto_view_builder", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/change_detection", "angular2/src/render/dom/view/proto_view", "angular2/src/render/dom/view/element_binder", "angular2/src/render/dom/view/property_setter_factory", "angular2/src/render/api", "angular2/src/render/dom/direct_dom_renderer", "angular2/src/render/dom/util"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/view/proto_view_builder"; - var assert, - isPresent, - isBlank, - BaseException, - ListWrapper, - MapWrapper, - Set, - SetWrapper, - List, - DOM, - ASTWithSource, - AST, - AstTransformer, - AccessMember, - LiteralArray, - ImplicitReceiver, - RenderProtoView, - ElementBinder, - Event, - setterFactory, - api, - directDomRenderer, - NG_BINDING_CLASS, - EVENT_TARGET_SEPARATOR, - ProtoViewBuilder, - ElementBinderBuilder, - DirectiveBuilder, - EventBuilder; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - Set = $__m.Set; - SetWrapper = $__m.SetWrapper; - List = $__m.List; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - ASTWithSource = $__m.ASTWithSource; - AST = $__m.AST; - AstTransformer = $__m.AstTransformer; - AccessMember = $__m.AccessMember; - LiteralArray = $__m.LiteralArray; - ImplicitReceiver = $__m.ImplicitReceiver; - }, function($__m) { - RenderProtoView = $__m.RenderProtoView; - }, function($__m) { - ElementBinder = $__m.ElementBinder; - Event = $__m.Event; - }, function($__m) { - setterFactory = $__m.setterFactory; - }, function($__m) { - api = $__m; - }, function($__m) { - directDomRenderer = $__m; - }, function($__m) { - NG_BINDING_CLASS = $__m.NG_BINDING_CLASS; - EVENT_TARGET_SEPARATOR = $__m.EVENT_TARGET_SEPARATOR; - }], - execute: function() { - ProtoViewBuilder = (function() { - function ProtoViewBuilder(rootElement) { - this.rootElement = rootElement; - this.elements = []; - this.variableBindings = MapWrapper.create(); - this.imperativeRendererId = null; - } - return ($traceurRuntime.createClass)(ProtoViewBuilder, { - setImperativeRendererId: function(id) { - assert.argumentTypes(id, assert.type.string); - this.imperativeRendererId = id; - return assert.returnType((this), ProtoViewBuilder); + setValue: function(el, value) { + el.value = value; + }, + getChecked: function(el) { + return el.checked; + }, + setChecked: function(el, value) { + el.checked = value; + }, + createTemplate: function(html) { + var t = document.createElement('template'); + t.innerHTML = html; + return t; + }, + createElement: function(tagName) { + var doc = arguments[1] !== (void 0) ? arguments[1] : document; + return doc.createElement(tagName); + }, + createTextNode: function(text) { + var doc = arguments[1] !== (void 0) ? arguments[1] : document; + return doc.createTextNode(text); + }, + createScriptTag: function(attrName, attrValue) { + var doc = arguments[2] !== (void 0) ? arguments[2] : document; + var el = doc.createElement('SCRIPT'); + el.setAttribute(attrName, attrValue); + return el; + }, + createStyleElement: function(css) { + var doc = arguments[1] !== (void 0) ? arguments[1] : document; + var style = doc.createElement('STYLE'); + style.innerText = css; + return style; + }, + createShadowRoot: function(el) { + return el.createShadowRoot(); + }, + getShadowRoot: function(el) { + return el.shadowRoot; + }, + getHost: function(el) { + return el.host; + }, + clone: function(node) { + return node.cloneNode(true); + }, + hasProperty: function(element, name) { + return name in element; + }, + getElementsByClassName: function(element, name) { + return element.getElementsByClassName(name); + }, + getElementsByTagName: function(element, name) { + return element.getElementsByTagName(name); + }, + classList: function(element) { + return Array.prototype.slice.call(element.classList, 0); + }, + addClass: function(element, classname) { + element.classList.add(classname); + }, + removeClass: function(element, classname) { + element.classList.remove(classname); + }, + hasClass: function(element, classname) { + return element.classList.contains(classname); }, - bindElement: function(element) { - var description = arguments[1] !== (void 0) ? arguments[1] : null; - var builder = new ElementBinderBuilder(this.elements.length, element, description); - ListWrapper.push(this.elements, builder); - DOM.addClass(element, NG_BINDING_CLASS); - return assert.returnType((builder), ElementBinderBuilder); + setStyle: function(element, stylename, stylevalue) { + element.style[stylename] = stylevalue; }, - bindVariable: function(name, value) { - MapWrapper.set(this.variableBindings, value, name); + removeStyle: function(element, stylename) { + element.style[stylename] = null; }, - build: function() { - var renderElementBinders = []; - var apiElementBinders = []; - ListWrapper.forEach(this.elements, (function(ebb) { - var propertySetters = MapWrapper.create(); - var apiDirectiveBinders = ListWrapper.map(ebb.directives, (function(dbb) { - ebb.eventBuilder.merge(dbb.eventBuilder); - MapWrapper.forEach(dbb.hostPropertyBindings, (function(_, hostPropertyName) { - MapWrapper.set(propertySetters, hostPropertyName, setterFactory(hostPropertyName)); - })); - return new api.DirectiveBinder({ - directiveIndex: dbb.directiveIndex, - propertyBindings: dbb.propertyBindings, - eventBindings: dbb.eventBindings, - hostPropertyBindings: dbb.hostPropertyBindings - }); - })); - MapWrapper.forEach(ebb.propertyBindings, (function(_, propertyName) { - MapWrapper.set(propertySetters, propertyName, setterFactory(propertyName)); - })); - var nestedProtoView = isPresent(ebb.nestedProtoView) ? ebb.nestedProtoView.build() : null; - var parentIndex = isPresent(ebb.parent) ? ebb.parent.index : -1; - ListWrapper.push(apiElementBinders, new api.ElementBinder({ - index: ebb.index, - parentIndex: parentIndex, - distanceToParent: ebb.distanceToParent, - directives: apiDirectiveBinders, - nestedProtoView: nestedProtoView, - propertyBindings: ebb.propertyBindings, - variableBindings: ebb.variableBindings, - eventBindings: ebb.eventBindings, - textBindings: ebb.textBindings, - readAttributes: ebb.readAttributes - })); - ListWrapper.push(renderElementBinders, new ElementBinder({ - textNodeIndices: ebb.textBindingIndices, - contentTagSelector: ebb.contentTagSelector, - parentIndex: parentIndex, - distanceToParent: ebb.distanceToParent, - nestedProtoView: isPresent(nestedProtoView) ? nestedProtoView.render.delegate : null, - componentId: ebb.componentId, - eventLocals: new LiteralArray(ebb.eventBuilder.buildEventLocals()), - localEvents: ebb.eventBuilder.buildLocalEvents(), - globalEvents: ebb.eventBuilder.buildGlobalEvents(), - propertySetters: propertySetters - })); - })); - return assert.returnType((new api.ProtoViewDto({ - render: new directDomRenderer.DirectDomProtoViewRef(new RenderProtoView({ - element: this.rootElement, - elementBinders: renderElementBinders, - imperativeRendererId: this.imperativeRendererId - })), - elementBinders: apiElementBinders, - variableBindings: this.variableBindings - })), api.ProtoViewDto); - } - }, {}); - }()); - $__export("ProtoViewBuilder", ProtoViewBuilder); - Object.defineProperty(ProtoViewBuilder.prototype.setImperativeRendererId, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - ElementBinderBuilder = (function() { - function ElementBinderBuilder(index, element, description) { - this.element = element; - this.index = index; - this.parent = null; - this.distanceToParent = 0; - this.directives = []; - this.nestedProtoView = null; - this.propertyBindings = MapWrapper.create(); - this.variableBindings = MapWrapper.create(); - this.eventBindings = ListWrapper.create(); - this.eventBuilder = new EventBuilder(); - this.textBindings = []; - this.textBindingIndices = []; - this.contentTagSelector = null; - this.componentId = null; - this.readAttributes = MapWrapper.create(); - } - return ($traceurRuntime.createClass)(ElementBinderBuilder, { - setParent: function(parent, distanceToParent) { - assert.argumentTypes(parent, ElementBinderBuilder, distanceToParent, assert.type.any); - this.parent = parent; - if (isPresent(parent)) { - this.distanceToParent = distanceToParent; - } - return assert.returnType((this), ElementBinderBuilder); + getStyle: function(element, stylename) { + return element.style[stylename]; }, - readAttribute: function(attrName) { - assert.argumentTypes(attrName, assert.type.string); - if (isBlank(MapWrapper.get(this.readAttributes, attrName))) { - MapWrapper.set(this.readAttributes, attrName, DOM.getAttribute(this.element, attrName)); + tagName: function(element) { + return element.tagName; + }, + attributeMap: function(element) { + var res = MapWrapper.create(); + var elAttrs = element.attributes; + for (var i = 0; i < elAttrs.length; i++) { + var attrib = elAttrs[i]; + MapWrapper.set(res, attrib.name, attrib.value); } + return res; }, - bindDirective: function(directiveIndex) { - assert.argumentTypes(directiveIndex, assert.type.number); - var directive = new DirectiveBuilder(directiveIndex); - ListWrapper.push(this.directives, directive); - return assert.returnType((directive), DirectiveBuilder); + hasAttribute: function(element, attribute) { + return element.hasAttribute(attribute); }, - bindNestedProtoView: function(rootElement) { - if (isPresent(this.nestedProtoView)) { - throw new BaseException('Only one nested view per element is allowed'); - } - this.nestedProtoView = new ProtoViewBuilder(rootElement); - return assert.returnType((this.nestedProtoView), ProtoViewBuilder); + getAttribute: function(element, attribute) { + return element.getAttribute(attribute); }, - bindProperty: function(name, expression) { - MapWrapper.set(this.propertyBindings, name, expression); - setterFactory(name); + setAttribute: function(element, name, value) { + element.setAttribute(name, value); }, - bindVariable: function(name, value) { - if (isPresent(this.nestedProtoView)) { - this.nestedProtoView.bindVariable(name, value); - } else { - MapWrapper.set(this.variableBindings, value, name); - } + removeAttribute: function(element, attribute) { + return element.removeAttribute(attribute); }, - bindEvent: function(name, expression) { - var target = arguments[2] !== (void 0) ? arguments[2] : null; - ListWrapper.push(this.eventBindings, this.eventBuilder.add(name, expression, target)); + templateAwareRoot: function(el) { + return this.isTemplateElement(el) ? this.content(el) : el; }, - bindText: function(index, expression) { - ListWrapper.push(this.textBindingIndices, index); - ListWrapper.push(this.textBindings, expression); + createHtmlDocument: function() { + return document.implementation.createHTMLDocument('fakeTitle'); }, - setContentTagSelector: function(value) { - assert.argumentTypes(value, assert.type.string); - this.contentTagSelector = value; + defaultDoc: function() { + return document; }, - setComponentId: function(componentId) { - assert.argumentTypes(componentId, assert.type.string); - this.componentId = componentId; - } - }, {}); - }()); - $__export("ElementBinderBuilder", ElementBinderBuilder); - Object.defineProperty(ElementBinderBuilder.prototype.setParent, "parameters", {get: function() { - return [[ElementBinderBuilder], []]; - }}); - Object.defineProperty(ElementBinderBuilder.prototype.readAttribute, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(ElementBinderBuilder.prototype.bindDirective, "parameters", {get: function() { - return [[assert.type.number]]; - }}); - Object.defineProperty(ElementBinderBuilder.prototype.setContentTagSelector, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(ElementBinderBuilder.prototype.setComponentId, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - DirectiveBuilder = (function() { - function DirectiveBuilder(directiveIndex) { - this.directiveIndex = directiveIndex; - this.propertyBindings = MapWrapper.create(); - this.hostPropertyBindings = MapWrapper.create(); - this.eventBindings = ListWrapper.create(); - this.eventBuilder = new EventBuilder(); - } - return ($traceurRuntime.createClass)(DirectiveBuilder, { - bindProperty: function(name, expression) { - MapWrapper.set(this.propertyBindings, name, expression); + getBoundingClientRect: function(el) { + return el.getBoundingClientRect(); }, - bindHostProperty: function(name, expression) { - MapWrapper.set(this.hostPropertyBindings, name, expression); + getTitle: function() { + return document.title; }, - bindEvent: function(name, expression) { - var target = arguments[2] !== (void 0) ? arguments[2] : null; - ListWrapper.push(this.eventBindings, this.eventBuilder.add(name, expression, target)); - } - }, {}); - }()); - $__export("DirectiveBuilder", DirectiveBuilder); - EventBuilder = (function($__super) { - function EventBuilder() { - $traceurRuntime.superConstructor(EventBuilder).call(this); - this.locals = []; - this.localEvents = []; - this.globalEvents = []; - this._implicitReceiver = new ImplicitReceiver(); - } - return ($traceurRuntime.createClass)(EventBuilder, { - add: function(name, source, target) { - assert.argumentTypes(name, assert.type.string, source, ASTWithSource, target, assert.type.string); - var adjustedAst = source.ast; - var fullName = isPresent(target) ? target + EVENT_TARGET_SEPARATOR + name : name; - var result = new api.EventBinding(fullName, new ASTWithSource(adjustedAst, source.source, source.location)); - var event = new Event(name, target, fullName); - if (isBlank(target)) { - ListWrapper.push(this.localEvents, event); - } else { - ListWrapper.push(this.globalEvents, event); + setTitle: function(newTitle) { + document.title = newTitle; + }, + elementMatches: function(n, selector) { + return n instanceof HTMLElement && n.matches(selector); + }, + isTemplateElement: function(el) { + return el instanceof HTMLElement && el.nodeName == "TEMPLATE"; + }, + isTextNode: function(node) { + return node.nodeType === Node.TEXT_NODE; + }, + isCommentNode: function(node) { + return node.nodeType === Node.COMMENT_NODE; + }, + isElementNode: function(node) { + return node.nodeType === Node.ELEMENT_NODE; + }, + hasShadowRoot: function(node) { + return node instanceof HTMLElement && isPresent(node.shadowRoot); + }, + isShadowRoot: function(node) { + return node instanceof DocumentFragment; + }, + importIntoDoc: function(node) { + var result = document.importNode(node, true); + if (this.isTemplateElement(result) && !this.content(result).childNodes.length && this.content(node).childNodes.length) { + var childNodes = this.content(node).childNodes; + for (var i = 0; i < childNodes.length; ++i) { + this.content(result).appendChild(this.importIntoDoc(childNodes[i])); + } } - return assert.returnType((result), api.EventBinding); + return result; }, - visitAccessMember: function(ast) { - var isEventAccess = false; - var current = ast; - while (!isEventAccess && (current instanceof AccessMember)) { - if (current.name == '$event') { - isEventAccess = true; + isPageRule: function(rule) { + return rule.type === CSSRule.PAGE_RULE; + }, + isStyleRule: function(rule) { + return rule.type === CSSRule.STYLE_RULE; + }, + isMediaRule: function(rule) { + return rule.type === CSSRule.MEDIA_RULE; + }, + isKeyframesRule: function(rule) { + return rule.type === CSSRule.KEYFRAMES_RULE; + }, + getHref: function(el) { + return el.href; + }, + getEventKey: function(event) { + var key = event.key; + if (isBlank(key)) { + key = event.keyIdentifier; + if (isBlank(key)) { + return 'Unidentified'; + } + if (key.startsWith('U+')) { + key = String.fromCharCode(parseInt(key.substring(2), 16)); + if (event.location === DOM_KEY_LOCATION_NUMPAD && _chromeNumKeyPadMap.hasOwnProperty(key)) { + key = _chromeNumKeyPadMap[key]; + } } - current = current.receiver; } - if (isEventAccess) { - ListWrapper.push(this.locals, ast); - var index = this.locals.length - 1; - return new AccessMember(this._implicitReceiver, ("" + index), (function(arr) { - return arr[index]; - }), null); - } else { - return ast; + if (_keyMap.hasOwnProperty(key)) { + key = _keyMap[key]; } + return key; }, - buildEventLocals: function() { - return this.locals; - }, - buildLocalEvents: function() { - return this.localEvents; + getGlobalEventTarget: function(target) { + if (target == "window") { + return window; + } else if (target == "document") { + return document; + } else if (target == "body") { + return document.body; + } }, - buildGlobalEvents: function() { - return this.globalEvents; + getHistory: function() { + return window.history; }, - merge: function(eventBuilder) { - assert.argumentTypes(eventBuilder, EventBuilder); - this._merge(this.localEvents, eventBuilder.localEvents); - this._merge(this.globalEvents, eventBuilder.globalEvents); - ListWrapper.concat(this.locals, eventBuilder.locals); + getLocation: function() { + return window.location; }, - _merge: function(host, tobeAdded) { - assert.argumentTypes(host, assert.genericType(List, Event), tobeAdded, assert.genericType(List, Event)); - var names = ListWrapper.create(); - for (var i = 0; i < host.length; i++) { - ListWrapper.push(names, host[i].fullName); - } - for (var j = 0; j < tobeAdded.length; j++) { - if (!ListWrapper.contains(names, tobeAdded[j].fullName)) { - ListWrapper.push(host, tobeAdded[j]); + getBaseHref: function() { + return relativePath(document.baseURI); + } + }, {makeCurrent: function() { + setRootDomAdapter(new BrowserDomAdapter()); + }}, $__super); + }(GenericBrowserDomAdapter)); + $__export("BrowserDomAdapter", BrowserDomAdapter); + urlParsingNode = null; + } + }; +}); + +System.register("angular2/src/core/compiler/directive_metadata_reader", ["angular2/di", "angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/directive_metadata", "angular2/src/reflection/reflection"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/compiler/directive_metadata_reader"; + var Injector, + Injectable, + Type, + isPresent, + BaseException, + stringify, + Directive, + Component, + DirectiveMetadata, + reflector, + DirectiveMetadataReader; + return { + setters: [function($__m) { + Injector = $__m.Injector; + }, function($__m) { + Injectable = $__m.Injectable; + }, function($__m) { + Type = $__m.Type; + isPresent = $__m.isPresent; + BaseException = $__m.BaseException; + stringify = $__m.stringify; + }, function($__m) { + Directive = $__m.Directive; + Component = $__m.Component; + }, function($__m) { + DirectiveMetadata = $__m.DirectiveMetadata; + }, function($__m) { + reflector = $__m.reflector; + }], + execute: function() { + DirectiveMetadataReader = (function() { + function DirectiveMetadataReader() {} + return ($traceurRuntime.createClass)(DirectiveMetadataReader, {read: function(type) { + var annotations = reflector.annotations(type); + if (isPresent(annotations)) { + for (var i = 0; i < annotations.length; i++) { + var annotation = annotations[i]; + if (annotation instanceof Directive) { + var resolvedInjectables = null; + if (annotation instanceof Component && isPresent(annotation.injectables)) { + resolvedInjectables = Injector.resolve(annotation.injectables); + } + return new DirectiveMetadata(type, annotation, resolvedInjectables); + } } } - } - }, {}, $__super); - }(AstTransformer)); - $__export("EventBuilder", EventBuilder); - Object.defineProperty(EventBuilder.prototype.add, "parameters", {get: function() { - return [[assert.type.string], [ASTWithSource], [assert.type.string]]; - }}); - Object.defineProperty(EventBuilder.prototype.visitAccessMember, "parameters", {get: function() { - return [[AccessMember]]; - }}); - Object.defineProperty(EventBuilder.prototype.merge, "parameters", {get: function() { - return [[EventBuilder]]; + throw new BaseException(("No Directive annotation found on " + stringify(type))); + }}, {}); + }()); + $__export("DirectiveMetadataReader", DirectiveMetadataReader); + Object.defineProperty(DirectiveMetadataReader, "annotations", {get: function() { + return [new Injectable()]; }}); - Object.defineProperty(EventBuilder.prototype._merge, "parameters", {get: function() { - return [[assert.genericType(List, Event)], [assert.genericType(List, Event)]]; + Object.defineProperty(DirectiveMetadataReader.prototype.read, "parameters", {get: function() { + return [[Type]]; }}); } }; }); -System.register("angular2/src/render/dom/compiler/compile_control", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_step"], function($__export) { +System.register("angular2/src/core/compiler/view_ref", ["angular2/src/facade/lang", "angular2/src/core/compiler/view", "angular2/src/render/api"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/compile_control"; - var assert, - isBlank, - List, - ListWrapper, - CompileElement, - CompileStep, - CompileControl; + var __moduleName = "angular2/src/core/compiler/view_ref"; + var isPresent, + viewModule, + RenderViewRef, + ViewRef, + ProtoViewRef; + function internalView(viewRef) { + return viewRef._view; + } + function internalProtoView(protoViewRef) { + return isPresent(protoViewRef) ? protoViewRef._protoView : null; + } + $__export("internalView", internalView); + $__export("internalProtoView", internalProtoView); return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isBlank = $__m.isBlank; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; + isPresent = $__m.isPresent; }, function($__m) { - CompileElement = $__m.CompileElement; + viewModule = $__m; }, function($__m) { - CompileStep = $__m.CompileStep; + RenderViewRef = $__m.RenderViewRef; }], execute: function() { - CompileControl = (function() { - function CompileControl(steps) { - this._steps = steps; - this._currentStepIndex = 0; - this._parent = null; - this._results = null; - this._additionalChildren = null; + Object.defineProperty(internalView, "parameters", {get: function() { + return [[ViewRef]]; + }}); + Object.defineProperty(internalProtoView, "parameters", {get: function() { + return [[ProtoViewRef]]; + }}); + ViewRef = (function() { + function ViewRef(view) { + this._view = view; } - return ($traceurRuntime.createClass)(CompileControl, { - internalProcess: function(results, startStepIndex, parent, current) { - assert.argumentTypes(results, assert.type.any, startStepIndex, assert.type.any, parent, CompileElement, current, CompileElement); - this._results = results; - var previousStepIndex = this._currentStepIndex; - var previousParent = this._parent; - this._ignoreCurrentElement = false; - for (var i = startStepIndex; i < this._steps.length && !this._ignoreCurrentElement; i++) { - var step = this._steps[i]; - this._parent = parent; - this._currentStepIndex = i; - step.process(parent, current, this); - parent = this._parent; - } - if (!this._ignoreCurrentElement) { - ListWrapper.push(results, current); - } - this._currentStepIndex = previousStepIndex; - this._parent = previousParent; - var localAdditionalChildren = this._additionalChildren; - this._additionalChildren = null; - return localAdditionalChildren; - }, - addParent: function(newElement) { - assert.argumentTypes(newElement, CompileElement); - this.internalProcess(this._results, this._currentStepIndex + 1, this._parent, newElement); - this._parent = newElement; - }, - addChild: function(element) { - assert.argumentTypes(element, CompileElement); - if (isBlank(this._additionalChildren)) { - this._additionalChildren = ListWrapper.create(); - } - ListWrapper.push(this._additionalChildren, element); + return ($traceurRuntime.createClass)(ViewRef, { + get render() { + return this._view.render; }, - ignoreCurrentElement: function() { - this._ignoreCurrentElement = true; + setLocal: function(contextName, value) { + this._view.setLocal(contextName, value); } }, {}); }()); - $__export("CompileControl", CompileControl); - Object.defineProperty(CompileControl.prototype.internalProcess, "parameters", {get: function() { - return [[], [], [CompileElement], [CompileElement]]; - }}); - Object.defineProperty(CompileControl.prototype.addParent, "parameters", {get: function() { - return [[CompileElement]]; + $__export("ViewRef", ViewRef); + Object.defineProperty(ViewRef, "parameters", {get: function() { + return [[viewModule.AppView]]; }}); - Object.defineProperty(CompileControl.prototype.addChild, "parameters", {get: function() { - return [[CompileElement]]; + Object.defineProperty(ViewRef.prototype.setLocal, "parameters", {get: function() { + return [[assert.type.string], [assert.type.any]]; }}); + ProtoViewRef = (function() { + function ProtoViewRef(protoView) { + this._protoView = protoView; + } + return ($traceurRuntime.createClass)(ProtoViewRef, {}, {}); + }()); + $__export("ProtoViewRef", ProtoViewRef); } }; }); -System.register("angular2/src/render/dom/compiler/template_loader", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/services/xhr", "angular2/src/render/api", "angular2/src/services/url_resolver"], function($__export) { +System.register("angular2/src/render/dom/view/proto_view", ["angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/render/dom/view/element_binder", "angular2/src/render/dom/util", "angular2/src/render/api"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/template_loader"; - var assert, - Injectable, - isBlank, - isPresent, - BaseException, - stringify, - Map, - MapWrapper, - StringMapWrapper, - StringMap, - PromiseWrapper, - Promise, + var __moduleName = "angular2/src/render/dom/view/proto_view"; + var isPresent, DOM, - XHR, - ViewDefinition, - UrlResolver, - TemplateLoader; + List, + ElementBinder, + NG_BINDING_CLASS, + RenderProtoViewRef, + DomProtoViewRef, + DomProtoView; + function resolveInternalDomProtoView(protoViewRef) { + var domProtoViewRef = protoViewRef; + return domProtoViewRef._protoView; + } + $__export("resolveInternalDomProtoView", resolveInternalDomProtoView); return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - BaseException = $__m.BaseException; - stringify = $__m.stringify; - }, function($__m) { - Map = $__m.Map; - MapWrapper = $__m.MapWrapper; - StringMapWrapper = $__m.StringMapWrapper; - StringMap = $__m.StringMap; - }, function($__m) { - PromiseWrapper = $__m.PromiseWrapper; - Promise = $__m.Promise; + setters: [function($__m) { + isPresent = $__m.isPresent; }, function($__m) { DOM = $__m.DOM; }, function($__m) { - XHR = $__m.XHR; + List = $__m.List; }, function($__m) { - ViewDefinition = $__m.ViewDefinition; + ElementBinder = $__m.ElementBinder; }, function($__m) { - UrlResolver = $__m.UrlResolver; + NG_BINDING_CLASS = $__m.NG_BINDING_CLASS; + }, function($__m) { + RenderProtoViewRef = $__m.RenderProtoViewRef; }], execute: function() { - TemplateLoader = (function() { - function TemplateLoader(xhr, urlResolver) { - assert.argumentTypes(xhr, XHR, urlResolver, UrlResolver); - this._xhr = xhr; - this._htmlCache = StringMapWrapper.create(); - } - return ($traceurRuntime.createClass)(TemplateLoader, {load: function(template) { - assert.argumentTypes(template, ViewDefinition); - if (isPresent(template.template)) { - return assert.returnType((PromiseWrapper.resolve(DOM.createTemplate(template.template))), Promise); - } - var url = template.absUrl; - if (isPresent(url)) { - var promise = StringMapWrapper.get(this._htmlCache, url); - if (isBlank(promise)) { - promise = this._xhr.get(url).then(function(html) { - var template = DOM.createTemplate(html); - return template; - }); - StringMapWrapper.set(this._htmlCache, url, promise); - } - return assert.returnType((promise), Promise); - } - throw new BaseException('View should have either the url or template property set'); - }}, {}); - }()); - $__export("TemplateLoader", TemplateLoader); - Object.defineProperty(TemplateLoader, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(TemplateLoader, "parameters", {get: function() { - return [[XHR], [UrlResolver]]; + Object.defineProperty(resolveInternalDomProtoView, "parameters", {get: function() { + return [[RenderProtoViewRef]]; }}); - Object.defineProperty(TemplateLoader.prototype.load, "parameters", {get: function() { - return [[ViewDefinition]]; + DomProtoViewRef = (function($__super) { + function DomProtoViewRef(protoView) { + $traceurRuntime.superConstructor(DomProtoViewRef).call(this); + this._protoView = protoView; + } + return ($traceurRuntime.createClass)(DomProtoViewRef, {}, {}, $__super); + }(RenderProtoViewRef)); + $__export("DomProtoViewRef", DomProtoViewRef); + Object.defineProperty(DomProtoViewRef, "parameters", {get: function() { + return [[DomProtoView]]; }}); + DomProtoView = (function() { + function DomProtoView($__1) { + var $__2 = $__1, + elementBinders = $__2.elementBinders, + element = $__2.element; + this.element = element; + this.elementBinders = elementBinders; + this.isTemplateElement = DOM.isTemplateElement(this.element); + this.rootBindingOffset = (isPresent(this.element) && DOM.hasClass(this.element, NG_BINDING_CLASS)) ? 1 : 0; + } + return ($traceurRuntime.createClass)(DomProtoView, {}, {}); + }()); + $__export("DomProtoView", DomProtoView); } }; }); -System.register("angular2/src/render/dom/compiler/directive_parser", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/change_detection", "angular2/src/render/dom/compiler/selector", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/api", "angular2/src/render/dom/util"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/light_dom", ["angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/content_tag"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/directive_parser"; - var assert, - isPresent, - isBlank, - BaseException, - assertionsEnabled, - RegExpWrapper, - StringWrapper, + var __moduleName = "angular2/src/render/dom/shadow_dom/light_dom"; + var DOM, List, - MapWrapper, ListWrapper, - DOM, - Parser, - SelectorMatcher, - CssSelector, - CompileStep, - CompileElement, - CompileControl, - DirectiveMetadata, - dashCaseToCamelCase, - camelCaseToDashCase, - EVENT_TARGET_SEPARATOR, - DirectiveParser; + isBlank, + isPresent, + viewModule, + Content, + DestinationLightDom, + _Root, + LightDom; + function redistributeNodes(contents, nodes) { + for (var i = 0; i < contents.length; ++i) { + var content = contents[i]; + var select = content.select; + if (select.length === 0) { + content.insert(ListWrapper.clone(nodes)); + ListWrapper.clear(nodes); + } else { + var matchSelector = (function(n) { + return DOM.elementMatches(n, select); + }); + var matchingNodes = ListWrapper.filter(nodes, matchSelector); + content.insert(matchingNodes); + ListWrapper.removeAll(nodes, matchingNodes); + } + } + for (var i = 0; i < nodes.length; i++) { + var node = nodes[i]; + if (isPresent(node.parentNode)) { + DOM.remove(nodes[i]); + } + } + } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - assertionsEnabled = $__m.assertionsEnabled; - RegExpWrapper = $__m.RegExpWrapper; - StringWrapper = $__m.StringWrapper; + DOM = $__m.DOM; }, function($__m) { List = $__m.List; - MapWrapper = $__m.MapWrapper; ListWrapper = $__m.ListWrapper; }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - Parser = $__m.Parser; - }, function($__m) { - SelectorMatcher = $__m.SelectorMatcher; - CssSelector = $__m.CssSelector; - }, function($__m) { - CompileStep = $__m.CompileStep; - }, function($__m) { - CompileElement = $__m.CompileElement; - }, function($__m) { - CompileControl = $__m.CompileControl; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; }, function($__m) { - DirectiveMetadata = $__m.DirectiveMetadata; + viewModule = $__m; }, function($__m) { - dashCaseToCamelCase = $__m.dashCaseToCamelCase; - camelCaseToDashCase = $__m.camelCaseToDashCase; - EVENT_TARGET_SEPARATOR = $__m.EVENT_TARGET_SEPARATOR; + Content = $__m.Content; }], execute: function() { - DirectiveParser = (function($__super) { - function DirectiveParser(parser, directives) { - assert.argumentTypes(parser, Parser, directives, assert.genericType(List, DirectiveMetadata)); - $traceurRuntime.superConstructor(DirectiveParser).call(this); - this._parser = parser; - this._selectorMatcher = new SelectorMatcher(); - this._directives = directives; - for (var i = 0; i < directives.length; i++) { - var directive = directives[i]; - var selector = CssSelector.parse(directive.selector); - this._ensureComponentOnlyHasElementSelector(selector, directive); - this._selectorMatcher.addSelectables(selector, i); - } + DestinationLightDom = (function() { + function DestinationLightDom() {} + return ($traceurRuntime.createClass)(DestinationLightDom, {}, {}); + }()); + $__export("DestinationLightDom", DestinationLightDom); + _Root = (function() { + function _Root(node, boundElementIndex) { + this.node = node; + this.boundElementIndex = boundElementIndex; } - return ($traceurRuntime.createClass)(DirectiveParser, { - _ensureComponentOnlyHasElementSelector: function(selector, directive) { - var isElementSelector = selector.length === 1 && selector[0].isElementSelector(); - if (!isElementSelector && directive.type === DirectiveMetadata.COMPONENT_TYPE) { - throw new BaseException(("Component '" + directive.id + "' can only have an element selector, but had '" + directive.selector + "'")); + return ($traceurRuntime.createClass)(_Root, {}, {}); + }()); + LightDom = (function() { + function LightDom(lightDomView, element) { + this.lightDomView = lightDomView; + this.nodes = DOM.childNodesAsList(element); + this.roots = null; + this.shadowDomView = null; + } + return ($traceurRuntime.createClass)(LightDom, { + attachShadowDomView: function(shadowDomView) { + this.shadowDomView = shadowDomView; + }, + detachShadowDomView: function() { + this.shadowDomView = null; + }, + redistribute: function() { + redistributeNodes(this.contentTags(), this.expandedDomNodes()); + }, + contentTags: function() { + if (isPresent(this.shadowDomView)) { + return this._collectAllContentTags(this.shadowDomView, []); + } else { + return []; } }, - process: function(parent, current, control) { + _collectAllContentTags: function(view, acc) { var $__0 = this; - assert.argumentTypes(parent, CompileElement, current, CompileElement, control, CompileControl); - var attrs = current.attrs(); - var classList = current.classList(); - var cssSelector = new CssSelector(); - var nodeName = DOM.nodeName(current.element); - cssSelector.setElement(nodeName); - for (var i = 0; i < classList.length; i++) { - cssSelector.addClassName(classList[i]); - } - MapWrapper.forEach(attrs, (function(attrValue, attrName) { - cssSelector.addAttribute(attrName, attrValue); - })); - var componentDirective; - this._selectorMatcher.match(cssSelector, (function(selector, directiveIndex) { - var elementBinder = current.bindElement(); - var directive = $__0._directives[directiveIndex]; - var directiveBinderBuilder = elementBinder.bindDirective(directiveIndex); - current.compileChildren = current.compileChildren && directive.compileChildren; - if (isPresent(directive.properties)) { - MapWrapper.forEach(directive.properties, (function(bindConfig, dirProperty) { - $__0._bindDirectiveProperty(dirProperty, bindConfig, current, directiveBinderBuilder); - })); - } - if (isPresent(directive.hostListeners)) { - MapWrapper.forEach(directive.hostListeners, (function(action, eventName) { - $__0._bindDirectiveEvent(eventName, action, current, directiveBinderBuilder); - })); - } - if (isPresent(directive.hostProperties)) { - MapWrapper.forEach(directive.hostProperties, (function(hostPropertyName, directivePropertyName) { - $__0._bindHostProperty(hostPropertyName, directivePropertyName, current, directiveBinderBuilder); - })); + var contentTags = view.contentTags; + var vcs = view.viewContainers; + for (var i = 0; i < vcs.length; i++) { + var vc = vcs[i]; + var contentTag = contentTags[i]; + if (isPresent(contentTag)) { + ListWrapper.push(acc, contentTag); } - if (isPresent(directive.readAttributes)) { - ListWrapper.forEach(directive.readAttributes, (function(attrName) { - elementBinder.readAttribute(attrName); + if (isPresent(vc)) { + ListWrapper.forEach(vc.contentTagContainers(), (function(view) { + $__0._collectAllContentTags(view, acc); })); } - if (directive.type === DirectiveMetadata.COMPONENT_TYPE) { - if (isPresent(componentDirective)) { - throw new BaseException(("Only one component directive is allowed per element - check " + current.elementDescription)); - } - componentDirective = directive; - elementBinder.setComponentId(directive.id); - } - })); - }, - _bindDirectiveProperty: function(dirProperty, bindConfig, compileElement, directiveBinderBuilder) { - var pipes = this._splitBindConfig(bindConfig); - var elProp = ListWrapper.removeAt(pipes, 0); - var bindingAst = MapWrapper.get(compileElement.bindElement().propertyBindings, dashCaseToCamelCase(elProp)); - if (isBlank(bindingAst)) { - var attributeValue = MapWrapper.get(compileElement.attrs(), camelCaseToDashCase(elProp)); - if (isPresent(attributeValue)) { - bindingAst = this._parser.wrapLiteralPrimitive(attributeValue, compileElement.elementDescription); - } - } - if (isPresent(bindingAst)) { - var fullExpAstWithBindPipes = this._parser.addPipes(bindingAst, pipes); - directiveBinderBuilder.bindProperty(dirProperty, fullExpAstWithBindPipes); } + return acc; }, - _bindDirectiveEvent: function(eventName, action, compileElement, directiveBinderBuilder) { - var ast = this._parser.parseAction(action, compileElement.elementDescription); - if (StringWrapper.contains(eventName, EVENT_TARGET_SEPARATOR)) { - var parts = eventName.split(EVENT_TARGET_SEPARATOR); - directiveBinderBuilder.bindEvent(parts[1], ast, parts[0]); - } else { - directiveBinderBuilder.bindEvent(eventName, ast); + expandedDomNodes: function() { + var res = []; + var roots = this._roots(); + for (var i = 0; i < roots.length; ++i) { + var root = roots[i]; + if (isPresent(root.boundElementIndex)) { + var vc = this.lightDomView.viewContainers[root.boundElementIndex]; + var content = this.lightDomView.contentTags[root.boundElementIndex]; + if (isPresent(vc)) { + res = ListWrapper.concat(res, vc.nodes()); + } else if (isPresent(content)) { + res = ListWrapper.concat(res, content.nodes()); + } else { + ListWrapper.push(res, root.node); + } + } else { + ListWrapper.push(res, root.node); + } } + return res; }, - _bindHostProperty: function(hostPropertyName, directivePropertyName, compileElement, directiveBinderBuilder) { - var ast = this._parser.parseBinding(directivePropertyName, ("hostProperties of " + compileElement.elementDescription)); - directiveBinderBuilder.bindHostProperty(hostPropertyName, ast); - }, - _splitBindConfig: function(bindConfig) { - return ListWrapper.map(bindConfig.split('|'), (function(s) { - return s.trim(); + _roots: function() { + if (isPresent(this.roots)) + return this.roots; + var boundElements = this.lightDomView.boundElements; + this.roots = ListWrapper.map(this.nodes, (function(n) { + var boundElementIndex = null; + for (var i = 0; i < boundElements.length; i++) { + var boundEl = boundElements[i]; + if (isPresent(boundEl) && boundEl === n) { + boundElementIndex = i; + break; + } + } + return new _Root(n, boundElementIndex); })); + return this.roots; } - }, {}, $__super); - }(CompileStep)); - $__export("DirectiveParser", DirectiveParser); - Object.defineProperty(DirectiveParser, "parameters", {get: function() { - return [[Parser], [assert.genericType(List, DirectiveMetadata)]]; + }, {}); + }()); + $__export("LightDom", LightDom); + Object.defineProperty(LightDom, "parameters", {get: function() { + return [[viewModule.DomView], []]; }}); - Object.defineProperty(DirectiveParser.prototype.process, "parameters", {get: function() { - return [[CompileElement], [CompileElement], [CompileControl]]; + Object.defineProperty(LightDom.prototype.attachShadowDomView, "parameters", {get: function() { + return [[viewModule.DomView]]; }}); - Object.defineProperty(DirectiveParser.prototype._splitBindConfig, "parameters", {get: function() { - return [[assert.type.string]]; + Object.defineProperty(LightDom.prototype._collectAllContentTags, "parameters", {get: function() { + return [[viewModule.DomView], [assert.genericType(List, Content)]]; + }}); + Object.defineProperty(redistributeNodes, "parameters", {get: function() { + return [[assert.genericType(List, Content)], [List]]; }}); } }; @@ -22845,11 +18452,95 @@ System.register("angular2/src/core/compiler/query_list", ["angular2/src/core/com }; }); -System.register("angular2/src/render/dom/shadow_dom/util", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/shadow_dom/shadow_css"], function($__export) { +System.register("angular2/src/render/dom/compiler/template_loader", ["angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/services/xhr", "angular2/src/render/api", "angular2/src/services/url_resolver"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/shadow_dom/util"; - var assert, + var __moduleName = "angular2/src/render/dom/compiler/template_loader"; + var Injectable, isBlank, + isPresent, + BaseException, + stringify, + Map, + MapWrapper, + StringMapWrapper, + StringMap, + PromiseWrapper, + Promise, + DOM, + XHR, + ViewDefinition, + UrlResolver, + TemplateLoader; + return { + setters: [function($__m) { + Injectable = $__m.Injectable; + }, function($__m) { + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + BaseException = $__m.BaseException; + stringify = $__m.stringify; + }, function($__m) { + Map = $__m.Map; + MapWrapper = $__m.MapWrapper; + StringMapWrapper = $__m.StringMapWrapper; + StringMap = $__m.StringMap; + }, function($__m) { + PromiseWrapper = $__m.PromiseWrapper; + Promise = $__m.Promise; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + XHR = $__m.XHR; + }, function($__m) { + ViewDefinition = $__m.ViewDefinition; + }, function($__m) { + UrlResolver = $__m.UrlResolver; + }], + execute: function() { + TemplateLoader = (function() { + function TemplateLoader(xhr, urlResolver) { + this._xhr = xhr; + this._htmlCache = StringMapWrapper.create(); + } + return ($traceurRuntime.createClass)(TemplateLoader, {load: function(template) { + if (isPresent(template.template)) { + return PromiseWrapper.resolve(DOM.createTemplate(template.template)); + } + var url = template.absUrl; + if (isPresent(url)) { + var promise = StringMapWrapper.get(this._htmlCache, url); + if (isBlank(promise)) { + promise = this._xhr.get(url).then(function(html) { + var template = DOM.createTemplate(html); + return template; + }); + StringMapWrapper.set(this._htmlCache, url, promise); + } + return promise.then((function(tplElement) { + return DOM.clone(tplElement); + })); + } + throw new BaseException('View should have either the url or template property set'); + }}, {}); + }()); + $__export("TemplateLoader", TemplateLoader); + Object.defineProperty(TemplateLoader, "annotations", {get: function() { + return [new Injectable()]; + }}); + Object.defineProperty(TemplateLoader, "parameters", {get: function() { + return [[XHR], [UrlResolver]]; + }}); + Object.defineProperty(TemplateLoader.prototype.load, "parameters", {get: function() { + return [[ViewDefinition]]; + }}); + } + }; +}); + +System.register("angular2/src/render/dom/shadow_dom/util", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/shadow_dom/shadow_css"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/shadow_dom/util"; + var isBlank, isPresent, int, MapWrapper, @@ -22860,13 +18551,7 @@ System.register("angular2/src/render/dom/shadow_dom/util", ["rtts_assert/rtts_as _nextComponentUID, _sharedStyleTexts, _lastInsertedStyleEl; - function moveViewNodesIntoParent(parent, view) { - for (var i = 0; i < view.rootNodes.length; ++i) { - DOM.appendChild(parent, view.rootNodes[i]); - } - } function getComponentId(componentStringId) { - assert.argumentTypes(componentStringId, assert.type.string); var id = MapWrapper.get(_componentUIDs, componentStringId); if (isBlank(id)) { id = _nextComponentUID++; @@ -22894,18 +18579,15 @@ System.register("angular2/src/render/dom/shadow_dom/util", ["rtts_assert/rtts_as _lastInsertedStyleEl = styleEl; } function getHostAttribute(id) { - assert.argumentTypes(id, int); return ("_nghost-" + id); } function getContentAttribute(id) { - assert.argumentTypes(id, int); return ("_ngcontent-" + id); } function shimCssForComponent(cssText, componentId) { - assert.argumentTypes(cssText, assert.type.string, componentId, assert.type.string); var id = getComponentId(componentId); var shadowCss = new ShadowCss(); - return assert.returnType((shadowCss.shimCssText(cssText, getContentAttribute(id), getHostAttribute(id))), assert.type.string); + return shadowCss.shimCssText(cssText, getContentAttribute(id), getHostAttribute(id)); } function resetShadowDomCache() { MapWrapper.clear(_componentUIDs); @@ -22913,7 +18595,6 @@ System.register("angular2/src/render/dom/shadow_dom/util", ["rtts_assert/rtts_as MapWrapper.clear(_sharedStyleTexts); _lastInsertedStyleEl = null; } - $__export("moveViewNodesIntoParent", moveViewNodesIntoParent); $__export("getComponentId", getComponentId); $__export("insertSharedStyleText", insertSharedStyleText); $__export("insertStyleElement", insertStyleElement); @@ -22923,8 +18604,6 @@ System.register("angular2/src/render/dom/shadow_dom/util", ["rtts_assert/rtts_as $__export("resetShadowDomCache", resetShadowDomCache); return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { isBlank = $__m.isBlank; isPresent = $__m.isPresent; int = $__m.int; @@ -22937,9 +18616,9 @@ System.register("angular2/src/render/dom/shadow_dom/util", ["rtts_assert/rtts_as ShadowCss = $__m.ShadowCss; }], execute: function() { - _componentUIDs = assert.type(MapWrapper.create(), assert.genericType(Map, assert.type.string, int)); - _nextComponentUID = assert.type(0, int); - _sharedStyleTexts = assert.type(MapWrapper.create(), assert.genericType(Map, assert.type.string, assert.type.boolean)); + _componentUIDs = MapWrapper.create(); + _nextComponentUID = 0; + _sharedStyleTexts = MapWrapper.create(); Object.defineProperty(getComponentId, "parameters", {get: function() { return [[assert.type.string]]; }}); @@ -22956,18 +18635,15 @@ System.register("angular2/src/render/dom/shadow_dom/util", ["rtts_assert/rtts_as }; }); -System.register("angular2/src/render/dom/events/hammer_gestures", ["rtts_assert/rtts_assert", "angular2/src/render/dom/events/hammer_common", "angular2/src/facade/lang"], function($__export) { +System.register("angular2/src/render/dom/events/hammer_gestures", ["angular2/src/render/dom/events/hammer_common", "angular2/src/facade/lang"], function($__export) { "use strict"; var __moduleName = "angular2/src/render/dom/events/hammer_gestures"; - var assert, - HammerGesturesPluginCommon, + var HammerGesturesPluginCommon, isPresent, BaseException, HammerGesturesPlugin; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { HammerGesturesPluginCommon = $__m.HammerGesturesPluginCommon; }, function($__m) { isPresent = $__m.isPresent; @@ -22980,16 +18656,14 @@ System.register("angular2/src/render/dom/events/hammer_gestures", ["rtts_assert/ } return ($traceurRuntime.createClass)(HammerGesturesPlugin, { supports: function(eventName) { - assert.argumentTypes(eventName, assert.type.string); if (!$traceurRuntime.superGet(this, HammerGesturesPlugin.prototype, "supports").call(this, eventName)) - return assert.returnType((false), assert.type.boolean); + return false; if (!isPresent(window.Hammer)) { throw new BaseException(("Hammer.js is not loaded, can not bind " + eventName + " event")); } - return assert.returnType((true), assert.type.boolean); + return true; }, addEventListener: function(element, eventName, handler, shouldSupportBubble) { - assert.argumentTypes(element, assert.type.any, eventName, assert.type.string, handler, Function, shouldSupportBubble, assert.type.boolean); if (shouldSupportBubble) throw new BaseException('Hammer.js plugin does not support bubbling gestures.'); var zone = this.manager.getZone(); @@ -23018,11 +18692,10 @@ System.register("angular2/src/render/dom/events/hammer_gestures", ["rtts_assert/ }; }); -System.register("angular2/src/core/testability/testability", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/core/testability/get_testability"], function($__export) { +System.register("angular2/src/core/testability/testability", ["angular2/src/di/annotations_impl", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/core/testability/get_testability"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/testability/testability"; - var assert, - Injectable, + var Injectable, DOM, Map, MapWrapper, @@ -23036,8 +18709,6 @@ System.register("angular2/src/core/testability/testability", ["rtts_assert/rtts_ TestabilityRegistry; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injectable = $__m.Injectable; }, function($__m) { DOM = $__m.DOM; @@ -23062,7 +18733,6 @@ System.register("angular2/src/core/testability/testability", ["rtts_assert/rtts_ return ($traceurRuntime.createClass)(Testability, { increaseCount: function() { var delta = arguments[0] !== (void 0) ? arguments[0] : 1; - assert.argumentTypes(delta, assert.type.number); this._pendingCount += delta; if (this._pendingCount < 0) { throw new BaseException('pending async requests below zero'); @@ -23077,18 +18747,16 @@ System.register("angular2/src/core/testability/testability", ["rtts_assert/rtts_ } }, whenStable: function(callback) { - assert.argumentTypes(callback, Function); ListWrapper.push(this._callbacks, callback); if (this._pendingCount === 0) { this._runCallbacks(); } }, getPendingCount: function() { - return assert.returnType((this._pendingCount), assert.type.number); + return this._pendingCount; }, findBindings: function(using, binding, exactMatch) { - assert.argumentTypes(using, assert.type.any, binding, assert.type.string, exactMatch, assert.type.boolean); - return assert.returnType(([]), List); + return []; } }, {}); }()); @@ -23112,20 +18780,19 @@ System.register("angular2/src/core/testability/testability", ["rtts_assert/rtts_ } return ($traceurRuntime.createClass)(TestabilityRegistry, { registerApplication: function(token, testability) { - assert.argumentTypes(token, assert.type.any, testability, Testability); MapWrapper.set(this._applications, token, testability); }, findTestabilityInTree: function(elem) { if (elem == null) { - return assert.returnType((null), Testability); + return null; } if (MapWrapper.contains(this._applications, elem)) { - return assert.returnType((MapWrapper.get(this._applications, elem)), Testability); + return MapWrapper.get(this._applications, elem); } if (DOM.isShadowRoot(elem)) { - return assert.returnType((this.findTestabilityInTree(DOM.getHost(elem))), Testability); + return this.findTestabilityInTree(DOM.getHost(elem)); } - return assert.returnType((this.findTestabilityInTree(DOM.parentElement(elem))), Testability); + return this.findTestabilityInTree(DOM.parentElement(elem)); } }, {}); }()); @@ -23140,1215 +18807,1038 @@ System.register("angular2/src/core/testability/testability", ["rtts_assert/rtts_ }; }); -System.register("angular2/annotations", ["angular2/src/core/annotations/annotations", "angular2/src/core/decorators/decorators"], function($__export) { - "use strict"; - var __moduleName = "angular2/annotations"; - var $__exportNames = {}; - var $__exportNames = {}; - return { - setters: [function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }], - execute: function() {} - }; -}); - -System.register("angular2/directives", ["angular2/src/directives/class", "angular2/src/directives/for", "angular2/src/directives/if", "angular2/src/directives/non_bindable", "angular2/src/directives/switch"], function($__export) { +System.register("angular2/src/render/dom/view/proto_view_builder", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/change_detection", "angular2/src/render/dom/view/proto_view", "angular2/src/render/dom/view/element_binder", "angular2/src/render/dom/view/property_setter_factory", "angular2/src/render/api", "angular2/src/render/dom/util"], function($__export) { "use strict"; - var __moduleName = "angular2/directives"; - var $__exportNames = {}; - var $__exportNames = {}; - var $__exportNames = {}; - var $__exportNames = {}; - var $__exportNames = {}; + var __moduleName = "angular2/src/render/dom/view/proto_view_builder"; + var isPresent, + isBlank, + BaseException, + ListWrapper, + MapWrapper, + Set, + SetWrapper, + List, + DOM, + ASTWithSource, + AST, + AstTransformer, + AccessMember, + LiteralArray, + ImplicitReceiver, + DomProtoView, + DomProtoViewRef, + resolveInternalDomProtoView, + ElementBinder, + Event, + HostAction, + setterFactory, + api, + NG_BINDING_CLASS, + EVENT_TARGET_SEPARATOR, + ProtoViewBuilder, + ElementBinderBuilder, + DirectiveBuilder, + EventBuilder; return { setters: [function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + BaseException = $__m.BaseException; }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + Set = $__m.Set; + SetWrapper = $__m.SetWrapper; + List = $__m.List; }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); + DOM = $__m.DOM; }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); + ASTWithSource = $__m.ASTWithSource; + AST = $__m.AST; + AstTransformer = $__m.AstTransformer; + AccessMember = $__m.AccessMember; + LiteralArray = $__m.LiteralArray; + ImplicitReceiver = $__m.ImplicitReceiver; }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }], - execute: function() {} - }; -}); - -System.register("angular2/src/forms/model", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/collection", "angular2/src/forms/validators"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/forms/model"; - var assert, - isPresent, - Observable, - EventEmitter, - ObservableWrapper, - StringMap, - StringMapWrapper, - ListWrapper, - List, - Validators, - VALID, - INVALID, - AbstractControl, - Control, - ControlGroup, - ControlArray; - return { - setters: [function($__m) { - assert = $__m.assert; + DomProtoView = $__m.DomProtoView; + DomProtoViewRef = $__m.DomProtoViewRef; + resolveInternalDomProtoView = $__m.resolveInternalDomProtoView; }, function($__m) { - isPresent = $__m.isPresent; + ElementBinder = $__m.ElementBinder; + Event = $__m.Event; + HostAction = $__m.HostAction; }, function($__m) { - Observable = $__m.Observable; - EventEmitter = $__m.EventEmitter; - ObservableWrapper = $__m.ObservableWrapper; + setterFactory = $__m.setterFactory; }, function($__m) { - StringMap = $__m.StringMap; - StringMapWrapper = $__m.StringMapWrapper; - ListWrapper = $__m.ListWrapper; - List = $__m.List; + api = $__m; }, function($__m) { - Validators = $__m.Validators; + NG_BINDING_CLASS = $__m.NG_BINDING_CLASS; + EVENT_TARGET_SEPARATOR = $__m.EVENT_TARGET_SEPARATOR; }], execute: function() { - VALID = "VALID"; - $__export("VALID", VALID); - INVALID = "INVALID"; - $__export("INVALID", INVALID); - AbstractControl = (function() { - function AbstractControl(validator) { - assert.argumentTypes(validator, Function); - this.validator = validator; - this._pristine = true; + ProtoViewBuilder = (function() { + function ProtoViewBuilder(rootElement) { + this.rootElement = rootElement; + this.elements = []; + this.variableBindings = MapWrapper.create(); } - return ($traceurRuntime.createClass)(AbstractControl, { - get value() { - return assert.returnType((this._value), assert.type.any); - }, - get status() { - return assert.returnType((this._status), assert.type.string); - }, - get valid() { - return assert.returnType((this._status === VALID), assert.type.boolean); - }, - get errors() { - return assert.returnType((this._errors), StringMap); - }, - get pristine() { - return assert.returnType((this._pristine), assert.type.boolean); - }, - get dirty() { - return assert.returnType((!this.pristine), assert.type.boolean); - }, - get valueChanges() { - return assert.returnType((this._valueChanges), Observable); + return ($traceurRuntime.createClass)(ProtoViewBuilder, { + bindElement: function(element) { + var description = arguments[1] !== (void 0) ? arguments[1] : null; + var builder = new ElementBinderBuilder(this.elements.length, element, description); + ListWrapper.push(this.elements, builder); + DOM.addClass(element, NG_BINDING_CLASS); + return builder; }, - setParent: function(parent) { - this._parent = parent; + bindVariable: function(name, value) { + MapWrapper.set(this.variableBindings, value, name); }, - _updateParent: function() { - if (isPresent(this._parent)) { - this._parent._updateValue(); - } + build: function() { + var renderElementBinders = []; + var apiElementBinders = []; + ListWrapper.forEach(this.elements, (function(ebb) { + var propertySetters = MapWrapper.create(); + var hostActions = MapWrapper.create(); + var apiDirectiveBinders = ListWrapper.map(ebb.directives, (function(dbb) { + ebb.eventBuilder.merge(dbb.eventBuilder); + MapWrapper.forEach(dbb.hostPropertyBindings, (function(_, hostPropertyName) { + MapWrapper.set(propertySetters, hostPropertyName, setterFactory(hostPropertyName)); + })); + ListWrapper.forEach(dbb.hostActions, (function(hostAction) { + MapWrapper.set(hostActions, hostAction.actionExpression, hostAction.expression); + })); + return new api.DirectiveBinder({ + directiveIndex: dbb.directiveIndex, + propertyBindings: dbb.propertyBindings, + eventBindings: dbb.eventBindings, + hostPropertyBindings: dbb.hostPropertyBindings + }); + })); + MapWrapper.forEach(ebb.propertyBindings, (function(_, propertyName) { + MapWrapper.set(propertySetters, propertyName, setterFactory(propertyName)); + })); + var nestedProtoView = isPresent(ebb.nestedProtoView) ? ebb.nestedProtoView.build() : null; + var parentIndex = isPresent(ebb.parent) ? ebb.parent.index : -1; + ListWrapper.push(apiElementBinders, new api.ElementBinder({ + index: ebb.index, + parentIndex: parentIndex, + distanceToParent: ebb.distanceToParent, + directives: apiDirectiveBinders, + nestedProtoView: nestedProtoView, + propertyBindings: ebb.propertyBindings, + variableBindings: ebb.variableBindings, + eventBindings: ebb.eventBindings, + textBindings: ebb.textBindings, + readAttributes: ebb.readAttributes + })); + ListWrapper.push(renderElementBinders, new ElementBinder({ + textNodeIndices: ebb.textBindingIndices, + contentTagSelector: ebb.contentTagSelector, + parentIndex: parentIndex, + distanceToParent: ebb.distanceToParent, + nestedProtoView: isPresent(nestedProtoView) ? resolveInternalDomProtoView(nestedProtoView.render) : null, + componentId: ebb.componentId, + eventLocals: new LiteralArray(ebb.eventBuilder.buildEventLocals()), + localEvents: ebb.eventBuilder.buildLocalEvents(), + globalEvents: ebb.eventBuilder.buildGlobalEvents(), + hostActions: hostActions, + propertySetters: propertySetters + })); + })); + return new api.ProtoViewDto({ + render: new DomProtoViewRef(new DomProtoView({ + element: this.rootElement, + elementBinders: renderElementBinders + })), + elementBinders: apiElementBinders, + variableBindings: this.variableBindings + }); } }, {}); }()); - Object.defineProperty(AbstractControl, "parameters", {get: function() { - return [[Function]]; - }}); - Control = (function($__super) { - function Control(value) { - var validator = arguments[1] !== (void 0) ? arguments[1] : Validators.nullValidator; - assert.argumentTypes(value, assert.type.any, validator, Function); - $traceurRuntime.superConstructor(Control).call(this, validator); - this._setValueErrorsStatus(value); - this._valueChanges = new EventEmitter(); - } - return ($traceurRuntime.createClass)(Control, { - updateValue: function(value) { - assert.argumentTypes(value, assert.type.any); - this._setValueErrorsStatus(value); - this._pristine = false; - ObservableWrapper.callNext(this._valueChanges, this._value); - this._updateParent(); - }, - _setValueErrorsStatus: function(value) { - this._value = value; - this._errors = this.validator(this); - this._status = isPresent(this._errors) ? INVALID : VALID; - } - }, {}, $__super); - }(AbstractControl)); - $__export("Control", Control); - Object.defineProperty(Control, "parameters", {get: function() { - return [[assert.type.any], [Function]]; - }}); - Object.defineProperty(Control.prototype.updateValue, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - ControlGroup = (function($__super) { - function ControlGroup(controls) { - var optionals = arguments[1] !== (void 0) ? arguments[1] : null; - var validator = arguments[2] !== (void 0) ? arguments[2] : Validators.group; - assert.argumentTypes(controls, StringMap, optionals, StringMap, validator, Function); - $traceurRuntime.superConstructor(ControlGroup).call(this, validator); - this.controls = controls; - this._optionals = isPresent(optionals) ? optionals : {}; - this._valueChanges = new EventEmitter(); - this._setParentForControls(); - this._setValueErrorsStatus(); + $__export("ProtoViewBuilder", ProtoViewBuilder); + ElementBinderBuilder = (function() { + function ElementBinderBuilder(index, element, description) { + this.element = element; + this.index = index; + this.parent = null; + this.distanceToParent = 0; + this.directives = []; + this.nestedProtoView = null; + this.propertyBindings = MapWrapper.create(); + this.variableBindings = MapWrapper.create(); + this.eventBindings = ListWrapper.create(); + this.eventBuilder = new EventBuilder(); + this.textBindings = []; + this.textBindingIndices = []; + this.contentTagSelector = null; + this.componentId = null; + this.readAttributes = MapWrapper.create(); } - return ($traceurRuntime.createClass)(ControlGroup, { - include: function(controlName) { - assert.argumentTypes(controlName, assert.type.string); - StringMapWrapper.set(this._optionals, controlName, true); - this._updateValue(); - }, - exclude: function(controlName) { - assert.argumentTypes(controlName, assert.type.string); - StringMapWrapper.set(this._optionals, controlName, false); - this._updateValue(); - }, - contains: function(controlName) { - assert.argumentTypes(controlName, assert.type.string); - var c = StringMapWrapper.contains(this.controls, controlName); - return assert.returnType((c && this._included(controlName)), assert.type.boolean); - }, - _setParentForControls: function() { - var $__0 = this; - StringMapWrapper.forEach(this.controls, (function(control, name) { - control.setParent($__0); - })); - }, - _updateValue: function() { - this._setValueErrorsStatus(); - this._pristine = false; - ObservableWrapper.callNext(this._valueChanges, this._value); - this._updateParent(); - }, - _setValueErrorsStatus: function() { - this._value = this._reduceValue(); - this._errors = this.validator(this); - this._status = isPresent(this._errors) ? INVALID : VALID; - }, - _reduceValue: function() { - return this._reduceChildren({}, (function(acc, control, name) { - acc[name] = control.value; - return acc; - })); - }, - _reduceChildren: function(initValue, fn) { - var $__0 = this; - assert.argumentTypes(initValue, assert.type.any, fn, Function); - var res = initValue; - StringMapWrapper.forEach(this.controls, (function(control, name) { - if ($__0._included(name)) { - res = fn(res, control, name); - } - })); - return res; + return ($traceurRuntime.createClass)(ElementBinderBuilder, { + setParent: function(parent, distanceToParent) { + this.parent = parent; + if (isPresent(parent)) { + this.distanceToParent = distanceToParent; + } + return this; }, - _included: function(controlName) { - assert.argumentTypes(controlName, assert.type.string); - var isOptional = StringMapWrapper.contains(this._optionals, controlName); - return assert.returnType((!isOptional || StringMapWrapper.get(this._optionals, controlName)), assert.type.boolean); - } - }, {}, $__super); - }(AbstractControl)); - $__export("ControlGroup", ControlGroup); - Object.defineProperty(ControlGroup, "parameters", {get: function() { - return [[StringMap], [StringMap], [Function]]; - }}); - Object.defineProperty(ControlGroup.prototype.include, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(ControlGroup.prototype.exclude, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(ControlGroup.prototype.contains, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(ControlGroup.prototype._reduceChildren, "parameters", {get: function() { - return [[assert.type.any], [Function]]; - }}); - Object.defineProperty(ControlGroup.prototype._included, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - ControlArray = (function($__super) { - function ControlArray(controls) { - var validator = arguments[1] !== (void 0) ? arguments[1] : Validators.array; - assert.argumentTypes(controls, assert.genericType(List, AbstractControl), validator, Function); - $traceurRuntime.superConstructor(ControlArray).call(this, validator); - this.controls = controls; - this._valueChanges = new EventEmitter(); - this._setParentForControls(); - this._setValueErrorsStatus(); - } - return ($traceurRuntime.createClass)(ControlArray, { - at: function(index) { - assert.argumentTypes(index, assert.type.number); - return assert.returnType((this.controls[index]), AbstractControl); + readAttribute: function(attrName) { + if (isBlank(MapWrapper.get(this.readAttributes, attrName))) { + MapWrapper.set(this.readAttributes, attrName, DOM.getAttribute(this.element, attrName)); + } }, - push: function(control) { - assert.argumentTypes(control, AbstractControl); - ListWrapper.push(this.controls, control); - control.setParent(this); - this._updateValue(); + bindDirective: function(directiveIndex) { + var directive = new DirectiveBuilder(directiveIndex); + ListWrapper.push(this.directives, directive); + return directive; }, - insert: function(index, control) { - assert.argumentTypes(index, assert.type.number, control, AbstractControl); - ListWrapper.insert(this.controls, index, control); - control.setParent(this); - this._updateValue(); + bindNestedProtoView: function(rootElement) { + if (isPresent(this.nestedProtoView)) { + throw new BaseException('Only one nested view per element is allowed'); + } + this.nestedProtoView = new ProtoViewBuilder(rootElement); + return this.nestedProtoView; }, - removeAt: function(index) { - assert.argumentTypes(index, assert.type.number); - ListWrapper.removeAt(this.controls, index); - this._updateValue(); + bindProperty: function(name, expression) { + MapWrapper.set(this.propertyBindings, name, expression); + setterFactory(name); }, - get length() { - return assert.returnType((this.controls.length), assert.type.number); + bindVariable: function(name, value) { + if (isPresent(this.nestedProtoView)) { + this.nestedProtoView.bindVariable(name, value); + } else { + MapWrapper.set(this.variableBindings, value, name); + } }, - _updateValue: function() { - this._setValueErrorsStatus(); - this._pristine = false; - ObservableWrapper.callNext(this._valueChanges, this._value); - this._updateParent(); + bindEvent: function(name, expression) { + var target = arguments[2] !== (void 0) ? arguments[2] : null; + ListWrapper.push(this.eventBindings, this.eventBuilder.add(name, expression, target)); }, - _setParentForControls: function() { - var $__0 = this; - ListWrapper.forEach(this.controls, (function(control) { - control.setParent($__0); - })); + bindText: function(index, expression) { + ListWrapper.push(this.textBindingIndices, index); + ListWrapper.push(this.textBindings, expression); }, - _setValueErrorsStatus: function() { - this._value = ListWrapper.map(this.controls, (function(c) { - return c.value; - })); - this._errors = this.validator(this); - this._status = isPresent(this._errors) ? INVALID : VALID; + setContentTagSelector: function(value) { + this.contentTagSelector = value; + }, + setComponentId: function(componentId) { + this.componentId = componentId; } - }, {}, $__super); - }(AbstractControl)); - $__export("ControlArray", ControlArray); - Object.defineProperty(ControlArray, "parameters", {get: function() { - return [[assert.genericType(List, AbstractControl)], [Function]]; + }, {}); + }()); + $__export("ElementBinderBuilder", ElementBinderBuilder); + Object.defineProperty(ElementBinderBuilder.prototype.setParent, "parameters", {get: function() { + return [[ElementBinderBuilder], []]; }}); - Object.defineProperty(ControlArray.prototype.at, "parameters", {get: function() { - return [[assert.type.number]]; + Object.defineProperty(ElementBinderBuilder.prototype.readAttribute, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(ControlArray.prototype.push, "parameters", {get: function() { - return [[AbstractControl]]; + Object.defineProperty(ElementBinderBuilder.prototype.bindDirective, "parameters", {get: function() { + return [[assert.type.number]]; }}); - Object.defineProperty(ControlArray.prototype.insert, "parameters", {get: function() { - return [[assert.type.number], [AbstractControl]]; + Object.defineProperty(ElementBinderBuilder.prototype.setContentTagSelector, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(ControlArray.prototype.removeAt, "parameters", {get: function() { - return [[assert.type.number]]; + Object.defineProperty(ElementBinderBuilder.prototype.setComponentId, "parameters", {get: function() { + return [[assert.type.string]]; }}); - } - }; -}); - -System.register("angular2/src/change_detection/parser/ast", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/parser/ast"; - var assert, - autoConvertAdd, - isBlank, - isPresent, - FunctionWrapper, - BaseException, - List, - Map, - ListWrapper, - StringMapWrapper, - AST, - EmptyExpr, - ImplicitReceiver, - Chain, - Conditional, - AccessMember, - KeyedAccess, - Pipe, - LiteralPrimitive, - LiteralArray, - LiteralMap, - Interpolation, - Binary, - PrefixNot, - Assignment, - MethodCall, - FunctionCall, - ASTWithSource, - TemplateBinding, - AstVisitor, - AstTransformer, - _evalListCache; - function evalList(context, locals, exps) { - assert.argumentTypes(context, assert.type.any, locals, assert.type.any, exps, List); - var length = exps.length; - if (length > 10) { - throw new BaseException("Cannot have more than 10 argument"); - } - var result = _evalListCache[length]; - for (var i = 0; i < length; i++) { - result[i] = exps[i].eval(context, locals); - } - return result; - } - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - autoConvertAdd = $__m.autoConvertAdd; - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - FunctionWrapper = $__m.FunctionWrapper; - BaseException = $__m.BaseException; - }, function($__m) { - List = $__m.List; - Map = $__m.Map; - ListWrapper = $__m.ListWrapper; - StringMapWrapper = $__m.StringMapWrapper; - }], - execute: function() { - AST = (function() { - function AST() {} - return ($traceurRuntime.createClass)(AST, { - eval: function(context, locals) { - throw new BaseException("Not supported"); + DirectiveBuilder = (function() { + function DirectiveBuilder(directiveIndex) { + this.directiveIndex = directiveIndex; + this.propertyBindings = MapWrapper.create(); + this.hostPropertyBindings = MapWrapper.create(); + this.hostActions = ListWrapper.create(); + this.eventBindings = ListWrapper.create(); + this.eventBuilder = new EventBuilder(); + } + return ($traceurRuntime.createClass)(DirectiveBuilder, { + bindProperty: function(name, expression) { + MapWrapper.set(this.propertyBindings, name, expression); }, - get isAssignable() { - return assert.returnType((false), assert.type.boolean); + bindHostProperty: function(name, expression) { + MapWrapper.set(this.hostPropertyBindings, name, expression); }, - assign: function(context, locals, value) { - throw new BaseException("Not supported"); + bindHostAction: function(actionName, actionExpression, expression) { + ListWrapper.push(this.hostActions, new HostAction(actionName, actionExpression, expression)); }, - visit: function(visitor) {}, - toString: function() { - return assert.returnType(("AST"), assert.type.string); + bindEvent: function(name, expression) { + var target = arguments[2] !== (void 0) ? arguments[2] : null; + ListWrapper.push(this.eventBindings, this.eventBuilder.add(name, expression, target)); } }, {}); }()); - $__export("AST", AST); - EmptyExpr = (function($__super) { - function EmptyExpr() { - $traceurRuntime.superConstructor(EmptyExpr).apply(this, arguments); - } - return ($traceurRuntime.createClass)(EmptyExpr, { - eval: function(context, locals) { - return null; - }, - visit: function(visitor) {} - }, {}, $__super); - }(AST)); - $__export("EmptyExpr", EmptyExpr); - ImplicitReceiver = (function($__super) { - function ImplicitReceiver() { - $traceurRuntime.superConstructor(ImplicitReceiver).apply(this, arguments); - } - return ($traceurRuntime.createClass)(ImplicitReceiver, { - eval: function(context, locals) { - return context; - }, - visit: function(visitor) { - return visitor.visitImplicitReceiver(this); - } - }, {}, $__super); - }(AST)); - $__export("ImplicitReceiver", ImplicitReceiver); - Chain = (function($__super) { - function Chain(expressions) { - assert.argumentTypes(expressions, List); - $traceurRuntime.superConstructor(Chain).call(this); - this.expressions = expressions; - } - return ($traceurRuntime.createClass)(Chain, { - eval: function(context, locals) { - var result; - for (var i = 0; i < this.expressions.length; i++) { - var last = this.expressions[i].eval(context, locals); - if (isPresent(last)) - result = last; - } - return result; - }, - visit: function(visitor) { - return visitor.visitChain(this); - } - }, {}, $__super); - }(AST)); - $__export("Chain", Chain); - Object.defineProperty(Chain, "parameters", {get: function() { - return [[List]]; - }}); - Conditional = (function($__super) { - function Conditional(condition, trueExp, falseExp) { - assert.argumentTypes(condition, AST, trueExp, AST, falseExp, AST); - $traceurRuntime.superConstructor(Conditional).call(this); - this.condition = condition; - this.trueExp = trueExp; - this.falseExp = falseExp; - } - return ($traceurRuntime.createClass)(Conditional, { - eval: function(context, locals) { - if (this.condition.eval(context, locals)) { - return this.trueExp.eval(context, locals); - } else { - return this.falseExp.eval(context, locals); - } - }, - visit: function(visitor) { - return visitor.visitConditional(this); - } - }, {}, $__super); - }(AST)); - $__export("Conditional", Conditional); - Object.defineProperty(Conditional, "parameters", {get: function() { - return [[AST], [AST], [AST]]; + $__export("DirectiveBuilder", DirectiveBuilder); + Object.defineProperty(DirectiveBuilder.prototype.bindHostAction, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], [ASTWithSource]]; }}); - AccessMember = (function($__super) { - function AccessMember(receiver, name, getter, setter) { - assert.argumentTypes(receiver, AST, name, assert.type.string, getter, Function, setter, Function); - $traceurRuntime.superConstructor(AccessMember).call(this); - this.receiver = receiver; - this.name = name; - this.getter = getter; - this.setter = setter; + EventBuilder = (function($__super) { + function EventBuilder() { + $traceurRuntime.superConstructor(EventBuilder).call(this); + this.locals = []; + this.localEvents = []; + this.globalEvents = []; + this._implicitReceiver = new ImplicitReceiver(); } - return ($traceurRuntime.createClass)(AccessMember, { - eval: function(context, locals) { - if (this.receiver instanceof ImplicitReceiver && isPresent(locals) && locals.contains(this.name)) { - return locals.get(this.name); + return ($traceurRuntime.createClass)(EventBuilder, { + add: function(name, source, target) { + var adjustedAst = source.ast; + var fullName = isPresent(target) ? target + EVENT_TARGET_SEPARATOR + name : name; + var result = new api.EventBinding(fullName, new ASTWithSource(adjustedAst, source.source, source.location)); + var event = new Event(name, target, fullName); + if (isBlank(target)) { + ListWrapper.push(this.localEvents, event); } else { - var evaluatedReceiver = this.receiver.eval(context, locals); - return this.getter(evaluatedReceiver); + ListWrapper.push(this.globalEvents, event); } + return result; }, - get isAssignable() { - return assert.returnType((true), assert.type.boolean); - }, - assign: function(context, locals, value) { - var evaluatedContext = this.receiver.eval(context, locals); - if (this.receiver instanceof ImplicitReceiver && isPresent(locals) && locals.contains(this.name)) { - throw new BaseException(("Cannot reassign a variable binding " + this.name)); + visitAccessMember: function(ast) { + var isEventAccess = false; + var current = ast; + while (!isEventAccess && (current instanceof AccessMember)) { + if (current.name == '$event') { + isEventAccess = true; + } + current = current.receiver; + } + if (isEventAccess) { + ListWrapper.push(this.locals, ast); + var index = this.locals.length - 1; + return new AccessMember(this._implicitReceiver, ("" + index), (function(arr) { + return arr[index]; + }), null); } else { - return this.setter(evaluatedContext, value); + return ast; } }, - visit: function(visitor) { - return visitor.visitAccessMember(this); - } - }, {}, $__super); - }(AST)); - $__export("AccessMember", AccessMember); - Object.defineProperty(AccessMember, "parameters", {get: function() { - return [[AST], [assert.type.string], [Function], [Function]]; - }}); - KeyedAccess = (function($__super) { - function KeyedAccess(obj, key) { - assert.argumentTypes(obj, AST, key, AST); - $traceurRuntime.superConstructor(KeyedAccess).call(this); - this.obj = obj; - this.key = key; - } - return ($traceurRuntime.createClass)(KeyedAccess, { - eval: function(context, locals) { - var obj = this.obj.eval(context, locals); - var key = this.key.eval(context, locals); - return obj[key]; - }, - get isAssignable() { - return assert.returnType((true), assert.type.boolean); + buildEventLocals: function() { + return this.locals; }, - assign: function(context, locals, value) { - var obj = this.obj.eval(context, locals); - var key = this.key.eval(context, locals); - obj[key] = value; - return value; + buildLocalEvents: function() { + return this.localEvents; }, - visit: function(visitor) { - return visitor.visitKeyedAccess(this); - } - }, {}, $__super); - }(AST)); - $__export("KeyedAccess", KeyedAccess); - Object.defineProperty(KeyedAccess, "parameters", {get: function() { - return [[AST], [AST]]; - }}); - Pipe = (function($__super) { - function Pipe(exp, name, args, inBinding) { - assert.argumentTypes(exp, AST, name, assert.type.string, args, List, inBinding, assert.type.boolean); - $traceurRuntime.superConstructor(Pipe).call(this); - this.exp = exp; - this.name = name; - this.args = args; - this.inBinding = inBinding; - } - return ($traceurRuntime.createClass)(Pipe, {visit: function(visitor) { - return visitor.visitPipe(this); - }}, {}, $__super); - }(AST)); - $__export("Pipe", Pipe); - Object.defineProperty(Pipe, "parameters", {get: function() { - return [[AST], [assert.type.string], [List], [assert.type.boolean]]; - }}); - LiteralPrimitive = (function($__super) { - function LiteralPrimitive(value) { - $traceurRuntime.superConstructor(LiteralPrimitive).call(this); - this.value = value; - } - return ($traceurRuntime.createClass)(LiteralPrimitive, { - eval: function(context, locals) { - return this.value; + buildGlobalEvents: function() { + return this.globalEvents; }, - visit: function(visitor) { - return visitor.visitLiteralPrimitive(this); - } - }, {}, $__super); - }(AST)); - $__export("LiteralPrimitive", LiteralPrimitive); - LiteralArray = (function($__super) { - function LiteralArray(expressions) { - assert.argumentTypes(expressions, List); - $traceurRuntime.superConstructor(LiteralArray).call(this); - this.expressions = expressions; - } - return ($traceurRuntime.createClass)(LiteralArray, { - eval: function(context, locals) { - return ListWrapper.map(this.expressions, (function(e) { - return e.eval(context, locals); - })); + merge: function(eventBuilder) { + this._merge(this.localEvents, eventBuilder.localEvents); + this._merge(this.globalEvents, eventBuilder.globalEvents); + ListWrapper.concat(this.locals, eventBuilder.locals); }, - visit: function(visitor) { - return visitor.visitLiteralArray(this); - } - }, {}, $__super); - }(AST)); - $__export("LiteralArray", LiteralArray); - Object.defineProperty(LiteralArray, "parameters", {get: function() { - return [[List]]; - }}); - LiteralMap = (function($__super) { - function LiteralMap(keys, values) { - assert.argumentTypes(keys, List, values, List); - $traceurRuntime.superConstructor(LiteralMap).call(this); - this.keys = keys; - this.values = values; - } - return ($traceurRuntime.createClass)(LiteralMap, { - eval: function(context, locals) { - var res = StringMapWrapper.create(); - for (var i = 0; i < this.keys.length; ++i) { - StringMapWrapper.set(res, this.keys[i], this.values[i].eval(context, locals)); + _merge: function(host, tobeAdded) { + var names = ListWrapper.create(); + for (var i = 0; i < host.length; i++) { + ListWrapper.push(names, host[i].fullName); + } + for (var j = 0; j < tobeAdded.length; j++) { + if (!ListWrapper.contains(names, tobeAdded[j].fullName)) { + ListWrapper.push(host, tobeAdded[j]); + } } - return res; - }, - visit: function(visitor) { - return visitor.visitLiteralMap(this); } }, {}, $__super); - }(AST)); - $__export("LiteralMap", LiteralMap); - Object.defineProperty(LiteralMap, "parameters", {get: function() { - return [[List], [List]]; + }(AstTransformer)); + $__export("EventBuilder", EventBuilder); + Object.defineProperty(EventBuilder.prototype.add, "parameters", {get: function() { + return [[assert.type.string], [ASTWithSource], [assert.type.string]]; }}); - Interpolation = (function($__super) { - function Interpolation(strings, expressions) { - assert.argumentTypes(strings, List, expressions, List); - $traceurRuntime.superConstructor(Interpolation).call(this); - this.strings = strings; - this.expressions = expressions; - } - return ($traceurRuntime.createClass)(Interpolation, { - eval: function(context, locals) { - throw new BaseException("evaluating an Interpolation is not supported"); - }, - visit: function(visitor) { - visitor.visitInterpolation(this); - } - }, {}, $__super); - }(AST)); - $__export("Interpolation", Interpolation); - Object.defineProperty(Interpolation, "parameters", {get: function() { - return [[List], [List]]; + Object.defineProperty(EventBuilder.prototype.visitAccessMember, "parameters", {get: function() { + return [[AccessMember]]; }}); - Binary = (function($__super) { - function Binary(operation, left, right) { - assert.argumentTypes(operation, assert.type.string, left, AST, right, AST); - $traceurRuntime.superConstructor(Binary).call(this); - this.operation = operation; - this.left = left; - this.right = right; + Object.defineProperty(EventBuilder.prototype.merge, "parameters", {get: function() { + return [[EventBuilder]]; + }}); + Object.defineProperty(EventBuilder.prototype._merge, "parameters", {get: function() { + return [[assert.genericType(List, Event)], [assert.genericType(List, Event)]]; + }}); + } + }; +}); + +System.register("angular2/src/render/dom/compiler/compile_control", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_step"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/compiler/compile_control"; + var isBlank, + List, + ListWrapper, + CompileElement, + CompileStep, + CompileControl; + return { + setters: [function($__m) { + isBlank = $__m.isBlank; + }, function($__m) { + List = $__m.List; + ListWrapper = $__m.ListWrapper; + }, function($__m) { + CompileElement = $__m.CompileElement; + }, function($__m) { + CompileStep = $__m.CompileStep; + }], + execute: function() { + CompileControl = (function() { + function CompileControl(steps) { + this._steps = steps; + this._currentStepIndex = 0; + this._parent = null; + this._results = null; + this._additionalChildren = null; } - return ($traceurRuntime.createClass)(Binary, { - eval: function(context, locals) { - var left = this.left.eval(context, locals); - switch (this.operation) { - case '&&': - return left && this.right.eval(context, locals); - case '||': - return left || this.right.eval(context, locals); - } - var right = this.right.eval(context, locals); - switch (this.operation) { - case '+': - return left + right; - case '-': - return left - right; - case '*': - return left * right; - case '/': - return left / right; - case '%': - return left % right; - case '==': - return left == right; - case '!=': - return left != right; - case '===': - return left === right; - case '!==': - return left !== right; - case '<': - return left < right; - case '>': - return left > right; - case '<=': - return left <= right; - case '>=': - return left >= right; - case '^': - return left ^ right; - case '&': - return left & right; + return ($traceurRuntime.createClass)(CompileControl, { + internalProcess: function(results, startStepIndex, parent, current) { + this._results = results; + var previousStepIndex = this._currentStepIndex; + var previousParent = this._parent; + this._ignoreCurrentElement = false; + for (var i = startStepIndex; i < this._steps.length && !this._ignoreCurrentElement; i++) { + var step = this._steps[i]; + this._parent = parent; + this._currentStepIndex = i; + step.process(parent, current, this); + parent = this._parent; } - throw 'Internal error [$operation] not handled'; + if (!this._ignoreCurrentElement) { + ListWrapper.push(results, current); + } + this._currentStepIndex = previousStepIndex; + this._parent = previousParent; + var localAdditionalChildren = this._additionalChildren; + this._additionalChildren = null; + return localAdditionalChildren; }, - visit: function(visitor) { - return visitor.visitBinary(this); - } - }, {}, $__super); - }(AST)); - $__export("Binary", Binary); - Object.defineProperty(Binary, "parameters", {get: function() { - return [[assert.type.string], [AST], [AST]]; - }}); - PrefixNot = (function($__super) { - function PrefixNot(expression) { - assert.argumentTypes(expression, AST); - $traceurRuntime.superConstructor(PrefixNot).call(this); - this.expression = expression; - } - return ($traceurRuntime.createClass)(PrefixNot, { - eval: function(context, locals) { - return !this.expression.eval(context, locals); + addParent: function(newElement) { + this.internalProcess(this._results, this._currentStepIndex + 1, this._parent, newElement); + this._parent = newElement; }, - visit: function(visitor) { - return visitor.visitPrefixNot(this); - } - }, {}, $__super); - }(AST)); - $__export("PrefixNot", PrefixNot); - Object.defineProperty(PrefixNot, "parameters", {get: function() { - return [[AST]]; - }}); - Assignment = (function($__super) { - function Assignment(target, value) { - assert.argumentTypes(target, AST, value, AST); - $traceurRuntime.superConstructor(Assignment).call(this); - this.target = target; - this.value = value; - } - return ($traceurRuntime.createClass)(Assignment, { - eval: function(context, locals) { - return this.target.assign(context, locals, this.value.eval(context, locals)); + addChild: function(element) { + if (isBlank(this._additionalChildren)) { + this._additionalChildren = ListWrapper.create(); + } + ListWrapper.push(this._additionalChildren, element); }, - visit: function(visitor) { - return visitor.visitAssignment(this); + ignoreCurrentElement: function() { + this._ignoreCurrentElement = true; } - }, {}, $__super); - }(AST)); - $__export("Assignment", Assignment); - Object.defineProperty(Assignment, "parameters", {get: function() { - return [[AST], [AST]]; + }, {}); + }()); + $__export("CompileControl", CompileControl); + Object.defineProperty(CompileControl.prototype.internalProcess, "parameters", {get: function() { + return [[], [], [CompileElement], [CompileElement]]; }}); - MethodCall = (function($__super) { - function MethodCall(receiver, name, fn, args) { - assert.argumentTypes(receiver, AST, name, assert.type.string, fn, Function, args, List); - $traceurRuntime.superConstructor(MethodCall).call(this); - this.receiver = receiver; - this.fn = fn; - this.args = args; - this.name = name; + Object.defineProperty(CompileControl.prototype.addParent, "parameters", {get: function() { + return [[CompileElement]]; + }}); + Object.defineProperty(CompileControl.prototype.addChild, "parameters", {get: function() { + return [[CompileElement]]; + }}); + } + }; +}); + +System.register("angular2/src/render/dom/compiler/directive_parser", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/change_detection", "angular2/src/render/dom/compiler/selector", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/api", "angular2/src/render/dom/util"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/compiler/directive_parser"; + var isPresent, + isBlank, + BaseException, + assertionsEnabled, + RegExpWrapper, + StringWrapper, + List, + MapWrapper, + ListWrapper, + DOM, + Parser, + SelectorMatcher, + CssSelector, + CompileStep, + CompileElement, + CompileControl, + DirectiveMetadata, + dashCaseToCamelCase, + camelCaseToDashCase, + EVENT_TARGET_SEPARATOR, + DirectiveParser; + return { + setters: [function($__m) { + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + BaseException = $__m.BaseException; + assertionsEnabled = $__m.assertionsEnabled; + RegExpWrapper = $__m.RegExpWrapper; + StringWrapper = $__m.StringWrapper; + }, function($__m) { + List = $__m.List; + MapWrapper = $__m.MapWrapper; + ListWrapper = $__m.ListWrapper; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + Parser = $__m.Parser; + }, function($__m) { + SelectorMatcher = $__m.SelectorMatcher; + CssSelector = $__m.CssSelector; + }, function($__m) { + CompileStep = $__m.CompileStep; + }, function($__m) { + CompileElement = $__m.CompileElement; + }, function($__m) { + CompileControl = $__m.CompileControl; + }, function($__m) { + DirectiveMetadata = $__m.DirectiveMetadata; + }, function($__m) { + dashCaseToCamelCase = $__m.dashCaseToCamelCase; + camelCaseToDashCase = $__m.camelCaseToDashCase; + EVENT_TARGET_SEPARATOR = $__m.EVENT_TARGET_SEPARATOR; + }], + execute: function() { + DirectiveParser = (function($__super) { + function DirectiveParser(parser, directives) { + $traceurRuntime.superConstructor(DirectiveParser).call(this); + this._parser = parser; + this._selectorMatcher = new SelectorMatcher(); + this._directives = directives; + for (var i = 0; i < directives.length; i++) { + var directive = directives[i]; + var selector = CssSelector.parse(directive.selector); + this._ensureComponentOnlyHasElementSelector(selector, directive); + this._selectorMatcher.addSelectables(selector, i); + } } - return ($traceurRuntime.createClass)(MethodCall, { - eval: function(context, locals) { - var evaluatedArgs = evalList(context, locals, this.args); - if (this.receiver instanceof ImplicitReceiver && isPresent(locals) && locals.contains(this.name)) { - var fn = locals.get(this.name); - return FunctionWrapper.apply(fn, evaluatedArgs); - } else { - var evaluatedReceiver = this.receiver.eval(context, locals); - return this.fn(evaluatedReceiver, evaluatedArgs); + return ($traceurRuntime.createClass)(DirectiveParser, { + _ensureComponentOnlyHasElementSelector: function(selector, directive) { + var isElementSelector = selector.length === 1 && selector[0].isElementSelector(); + if (!isElementSelector && directive.type === DirectiveMetadata.COMPONENT_TYPE) { + throw new BaseException(("Component '" + directive.id + "' can only have an element selector, but had '" + directive.selector + "'")); } }, - visit: function(visitor) { - return visitor.visitMethodCall(this); - } - }, {}, $__super); - }(AST)); - $__export("MethodCall", MethodCall); - Object.defineProperty(MethodCall, "parameters", {get: function() { - return [[AST], [assert.type.string], [Function], [List]]; - }}); - FunctionCall = (function($__super) { - function FunctionCall(target, args) { - assert.argumentTypes(target, AST, args, List); - $traceurRuntime.superConstructor(FunctionCall).call(this); - this.target = target; - this.args = args; - } - return ($traceurRuntime.createClass)(FunctionCall, { - eval: function(context, locals) { - var obj = this.target.eval(context, locals); - if (!(obj instanceof Function)) { - throw new BaseException((obj + " is not a function")); + process: function(parent, current, control) { + var $__0 = this; + var attrs = current.attrs(); + var classList = current.classList(); + var cssSelector = new CssSelector(); + var nodeName = DOM.nodeName(current.element); + cssSelector.setElement(nodeName); + for (var i = 0; i < classList.length; i++) { + cssSelector.addClassName(classList[i]); + } + MapWrapper.forEach(attrs, (function(attrValue, attrName) { + cssSelector.addAttribute(attrName, attrValue); + })); + var componentDirective; + this._selectorMatcher.match(cssSelector, (function(selector, directiveIndex) { + var elementBinder = current.bindElement(); + var directive = $__0._directives[directiveIndex]; + var directiveBinderBuilder = elementBinder.bindDirective(directiveIndex); + current.compileChildren = current.compileChildren && directive.compileChildren; + if (isPresent(directive.properties)) { + MapWrapper.forEach(directive.properties, (function(bindConfig, dirProperty) { + $__0._bindDirectiveProperty(dirProperty, bindConfig, current, directiveBinderBuilder); + })); + } + if (isPresent(directive.hostListeners)) { + MapWrapper.forEach(directive.hostListeners, (function(action, eventName) { + $__0._bindDirectiveEvent(eventName, action, current, directiveBinderBuilder); + })); + } + if (isPresent(directive.hostActions)) { + MapWrapper.forEach(directive.hostActions, (function(action, actionName) { + $__0._bindHostAction(actionName, action, current, directiveBinderBuilder); + })); + } + if (isPresent(directive.hostProperties)) { + MapWrapper.forEach(directive.hostProperties, (function(hostPropertyName, directivePropertyName) { + $__0._bindHostProperty(hostPropertyName, directivePropertyName, current, directiveBinderBuilder); + })); + } + if (isPresent(directive.hostAttributes)) { + MapWrapper.forEach(directive.hostAttributes, (function(hostAttrValue, hostAttrName) { + if (!DOM.hasAttribute(current.element, hostAttrName)) { + DOM.setAttribute(current.element, hostAttrName, hostAttrValue); + } + })); + } + if (isPresent(directive.readAttributes)) { + ListWrapper.forEach(directive.readAttributes, (function(attrName) { + elementBinder.readAttribute(attrName); + })); + } + if (directive.type === DirectiveMetadata.COMPONENT_TYPE) { + if (isPresent(componentDirective)) { + throw new BaseException(("Only one component directive is allowed per element - check " + current.elementDescription)); + } + componentDirective = directive; + elementBinder.setComponentId(directive.id); + } + })); + }, + _bindDirectiveProperty: function(dirProperty, bindConfig, compileElement, directiveBinderBuilder) { + var pipes = this._splitBindConfig(bindConfig); + var elProp = ListWrapper.removeAt(pipes, 0); + var bindingAst = MapWrapper.get(compileElement.bindElement().propertyBindings, dashCaseToCamelCase(elProp)); + if (isBlank(bindingAst)) { + var attributeValue = MapWrapper.get(compileElement.attrs(), camelCaseToDashCase(elProp)); + if (isPresent(attributeValue)) { + bindingAst = this._parser.wrapLiteralPrimitive(attributeValue, compileElement.elementDescription); + } + } + if (isPresent(bindingAst)) { + var fullExpAstWithBindPipes = this._parser.addPipes(bindingAst, pipes); + directiveBinderBuilder.bindProperty(dirProperty, fullExpAstWithBindPipes); + } + }, + _bindDirectiveEvent: function(eventName, action, compileElement, directiveBinderBuilder) { + var ast = this._parser.parseAction(action, compileElement.elementDescription); + if (StringWrapper.contains(eventName, EVENT_TARGET_SEPARATOR)) { + var parts = eventName.split(EVENT_TARGET_SEPARATOR); + directiveBinderBuilder.bindEvent(parts[1], ast, parts[0]); + } else { + directiveBinderBuilder.bindEvent(eventName, ast); } - return FunctionWrapper.apply(obj, evalList(context, locals, this.args)); }, - visit: function(visitor) { - return visitor.visitFunctionCall(this); + _bindHostAction: function(actionName, actionExpression, compileElement, directiveBinderBuilder) { + var ast = this._parser.parseAction(actionExpression, compileElement.elementDescription); + directiveBinderBuilder.bindHostAction(actionName, actionExpression, ast); + }, + _bindHostProperty: function(hostPropertyName, directivePropertyName, compileElement, directiveBinderBuilder) { + var ast = this._parser.parseBinding(directivePropertyName, ("hostProperties of " + compileElement.elementDescription)); + directiveBinderBuilder.bindHostProperty(hostPropertyName, ast); + }, + _splitBindConfig: function(bindConfig) { + return ListWrapper.map(bindConfig.split('|'), (function(s) { + return s.trim(); + })); } }, {}, $__super); - }(AST)); - $__export("FunctionCall", FunctionCall); - Object.defineProperty(FunctionCall, "parameters", {get: function() { - return [[AST], [List]]; + }(CompileStep)); + $__export("DirectiveParser", DirectiveParser); + Object.defineProperty(DirectiveParser, "parameters", {get: function() { + return [[Parser], [assert.genericType(List, DirectiveMetadata)]]; }}); - ASTWithSource = (function($__super) { - function ASTWithSource(ast, source, location) { - assert.argumentTypes(ast, AST, source, assert.type.string, location, assert.type.string); - $traceurRuntime.superConstructor(ASTWithSource).call(this); - this.source = source; - this.location = location; - this.ast = ast; + Object.defineProperty(DirectiveParser.prototype.process, "parameters", {get: function() { + return [[CompileElement], [CompileElement], [CompileControl]]; + }}); + Object.defineProperty(DirectiveParser.prototype._splitBindConfig, "parameters", {get: function() { + return [[assert.type.string]]; + }}); + } + }; +}); + +System.register("angular2/annotations", ["angular2/src/core/annotations/annotations", "angular2/src/core/annotations/decorators"], function($__export) { + "use strict"; + var __moduleName = "angular2/annotations"; + var $__exportNames = {}; + var $__exportNames = {}; + return { + setters: [function($__m) { + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }], + execute: function() {} + }; +}); + +System.register("angular2/directives", ["angular2/src/facade/lang", "angular2/src/directives/ng_for", "angular2/src/directives/ng_if", "angular2/src/directives/ng_non_bindable", "angular2/src/directives/ng_switch", "angular2/src/directives/class"], function($__export) { + "use strict"; + var __moduleName = "angular2/directives"; + var CONST_EXPR, + NgFor, + NgIf, + NgNonBindable, + NgSwitch, + NgSwitchWhen, + NgSwitchDefault, + coreDirectives; + var $__exportNames = {coreDirectives: true}; + var $__exportNames = {coreDirectives: true}; + var $__exportNames = {coreDirectives: true}; + var $__exportNames = {coreDirectives: true}; + var $__exportNames = {coreDirectives: true}; + return { + setters: [function($__m) { + CONST_EXPR = $__m.CONST_EXPR; + }, function($__m) { + NgFor = $__m.NgFor; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + NgIf = $__m.NgIf; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + NgNonBindable = $__m.NgNonBindable; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + NgSwitch = $__m.NgSwitch; + NgSwitchWhen = $__m.NgSwitchWhen; + NgSwitchDefault = $__m.NgSwitchDefault; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }], + execute: function() { + coreDirectives = CONST_EXPR([NgFor, NgIf, NgNonBindable, NgSwitch, NgSwitchWhen, NgSwitchDefault]); + $__export("coreDirectives", coreDirectives); + } + }; +}); + +System.register("angular2/src/forms/model", ["angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/collection", "angular2/src/forms/validators"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/forms/model"; + var isPresent, + Observable, + EventEmitter, + ObservableWrapper, + StringMap, + StringMapWrapper, + ListWrapper, + List, + Validators, + VALID, + INVALID, + AbstractControl, + Control, + ControlGroup, + ControlArray; + return { + setters: [function($__m) { + isPresent = $__m.isPresent; + }, function($__m) { + Observable = $__m.Observable; + EventEmitter = $__m.EventEmitter; + ObservableWrapper = $__m.ObservableWrapper; + }, function($__m) { + StringMap = $__m.StringMap; + StringMapWrapper = $__m.StringMapWrapper; + ListWrapper = $__m.ListWrapper; + List = $__m.List; + }, function($__m) { + Validators = $__m.Validators; + }], + execute: function() { + VALID = "VALID"; + $__export("VALID", VALID); + INVALID = "INVALID"; + $__export("INVALID", INVALID); + AbstractControl = (function() { + function AbstractControl(validator) { + this.validator = validator; + this._pristine = true; } - return ($traceurRuntime.createClass)(ASTWithSource, { - eval: function(context, locals) { - return this.ast.eval(context, locals); + return ($traceurRuntime.createClass)(AbstractControl, { + get value() { + return this._value; }, - get isAssignable() { - return assert.returnType((this.ast.isAssignable), assert.type.boolean); + get status() { + return this._status; }, - assign: function(context, locals, value) { - return this.ast.assign(context, locals, value); + get valid() { + return this._status === VALID; }, - visit: function(visitor) { - return this.ast.visit(visitor); + get errors() { + return this._errors; }, - toString: function() { - return assert.returnType(((this.source + " in " + this.location)), assert.type.string); - } - }, {}, $__super); - }(AST)); - $__export("ASTWithSource", ASTWithSource); - Object.defineProperty(ASTWithSource, "parameters", {get: function() { - return [[AST], [assert.type.string], [assert.type.string]]; - }}); - TemplateBinding = (function() { - function TemplateBinding(key, keyIsVar, name, expression) { - assert.argumentTypes(key, assert.type.string, keyIsVar, assert.type.boolean, name, assert.type.string, expression, ASTWithSource); - this.key = key; - this.keyIsVar = keyIsVar; - this.name = name; - this.expression = expression; - } - return ($traceurRuntime.createClass)(TemplateBinding, {}, {}); - }()); - $__export("TemplateBinding", TemplateBinding); - Object.defineProperty(TemplateBinding, "parameters", {get: function() { - return [[assert.type.string], [assert.type.boolean], [assert.type.string], [ASTWithSource]]; - }}); - AstVisitor = (function() { - function AstVisitor() {} - return ($traceurRuntime.createClass)(AstVisitor, { - visitAccessMember: function(ast) { - assert.argumentTypes(ast, AccessMember); + get pristine() { + return this._pristine; }, - visitAssignment: function(ast) { - assert.argumentTypes(ast, Assignment); + get dirty() { + return !this.pristine; }, - visitBinary: function(ast) { - assert.argumentTypes(ast, Binary); + get valueChanges() { + return this._valueChanges; }, - visitChain: function(ast) { - assert.argumentTypes(ast, Chain); + setParent: function(parent) { + this._parent = parent; }, - visitConditional: function(ast) { - assert.argumentTypes(ast, Conditional); + _updateParent: function() { + if (isPresent(this._parent)) { + this._parent._updateValue(); + } + } + }, {}); + }()); + Object.defineProperty(AbstractControl, "parameters", {get: function() { + return [[Function]]; + }}); + Control = (function($__super) { + function Control(value) { + var validator = arguments[1] !== (void 0) ? arguments[1] : Validators.nullValidator; + $traceurRuntime.superConstructor(Control).call(this, validator); + this._setValueErrorsStatus(value); + this._valueChanges = new EventEmitter(); + } + return ($traceurRuntime.createClass)(Control, { + updateValue: function(value) { + this._setValueErrorsStatus(value); + this._pristine = false; + ObservableWrapper.callNext(this._valueChanges, this._value); + this._updateParent(); }, - visitPipe: function(ast) { - assert.argumentTypes(ast, Pipe); + _setValueErrorsStatus: function(value) { + this._value = value; + this._errors = this.validator(this); + this._status = isPresent(this._errors) ? INVALID : VALID; + } + }, {}, $__super); + }(AbstractControl)); + $__export("Control", Control); + Object.defineProperty(Control, "parameters", {get: function() { + return [[assert.type.any], [Function]]; + }}); + Object.defineProperty(Control.prototype.updateValue, "parameters", {get: function() { + return [[assert.type.any]]; + }}); + ControlGroup = (function($__super) { + function ControlGroup(controls) { + var optionals = arguments[1] !== (void 0) ? arguments[1] : null; + var validator = arguments[2] !== (void 0) ? arguments[2] : Validators.group; + $traceurRuntime.superConstructor(ControlGroup).call(this, validator); + this.controls = controls; + this._optionals = isPresent(optionals) ? optionals : {}; + this._valueChanges = new EventEmitter(); + this._setParentForControls(); + this._setValueErrorsStatus(); + } + return ($traceurRuntime.createClass)(ControlGroup, { + include: function(controlName) { + StringMapWrapper.set(this._optionals, controlName, true); + this._updateValue(); }, - visitFunctionCall: function(ast) { - assert.argumentTypes(ast, FunctionCall); + exclude: function(controlName) { + StringMapWrapper.set(this._optionals, controlName, false); + this._updateValue(); }, - visitImplicitReceiver: function(ast) { - assert.argumentTypes(ast, ImplicitReceiver); + contains: function(controlName) { + var c = StringMapWrapper.contains(this.controls, controlName); + return c && this._included(controlName); }, - visitKeyedAccess: function(ast) { - assert.argumentTypes(ast, KeyedAccess); + _setParentForControls: function() { + var $__0 = this; + StringMapWrapper.forEach(this.controls, (function(control, name) { + control.setParent($__0); + })); }, - visitLiteralArray: function(ast) { - assert.argumentTypes(ast, LiteralArray); + _updateValue: function() { + this._setValueErrorsStatus(); + this._pristine = false; + ObservableWrapper.callNext(this._valueChanges, this._value); + this._updateParent(); }, - visitLiteralMap: function(ast) { - assert.argumentTypes(ast, LiteralMap); + _setValueErrorsStatus: function() { + this._value = this._reduceValue(); + this._errors = this.validator(this); + this._status = isPresent(this._errors) ? INVALID : VALID; }, - visitLiteralPrimitive: function(ast) { - assert.argumentTypes(ast, LiteralPrimitive); + _reduceValue: function() { + return this._reduceChildren({}, (function(acc, control, name) { + acc[name] = control.value; + return acc; + })); }, - visitMethodCall: function(ast) { - assert.argumentTypes(ast, MethodCall); + _reduceChildren: function(initValue, fn) { + var $__0 = this; + var res = initValue; + StringMapWrapper.forEach(this.controls, (function(control, name) { + if ($__0._included(name)) { + res = fn(res, control, name); + } + })); + return res; }, - visitPrefixNot: function(ast) { - assert.argumentTypes(ast, PrefixNot); + _included: function(controlName) { + var isOptional = StringMapWrapper.contains(this._optionals, controlName); + return !isOptional || StringMapWrapper.get(this._optionals, controlName); } - }, {}); - }()); - $__export("AstVisitor", AstVisitor); - Object.defineProperty(AstVisitor.prototype.visitAccessMember, "parameters", {get: function() { - return [[AccessMember]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitAssignment, "parameters", {get: function() { - return [[Assignment]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitBinary, "parameters", {get: function() { - return [[Binary]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitChain, "parameters", {get: function() { - return [[Chain]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitConditional, "parameters", {get: function() { - return [[Conditional]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitPipe, "parameters", {get: function() { - return [[Pipe]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitFunctionCall, "parameters", {get: function() { - return [[FunctionCall]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitImplicitReceiver, "parameters", {get: function() { - return [[ImplicitReceiver]]; - }}); - Object.defineProperty(AstVisitor.prototype.visitKeyedAccess, "parameters", {get: function() { - return [[KeyedAccess]]; + }, {}, $__super); + }(AbstractControl)); + $__export("ControlGroup", ControlGroup); + Object.defineProperty(ControlGroup, "parameters", {get: function() { + return [[StringMap], [StringMap], [Function]]; }}); - Object.defineProperty(AstVisitor.prototype.visitLiteralArray, "parameters", {get: function() { - return [[LiteralArray]]; + Object.defineProperty(ControlGroup.prototype.include, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(AstVisitor.prototype.visitLiteralMap, "parameters", {get: function() { - return [[LiteralMap]]; + Object.defineProperty(ControlGroup.prototype.exclude, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(AstVisitor.prototype.visitLiteralPrimitive, "parameters", {get: function() { - return [[LiteralPrimitive]]; + Object.defineProperty(ControlGroup.prototype.contains, "parameters", {get: function() { + return [[assert.type.string]]; }}); - Object.defineProperty(AstVisitor.prototype.visitMethodCall, "parameters", {get: function() { - return [[MethodCall]]; + Object.defineProperty(ControlGroup.prototype._reduceChildren, "parameters", {get: function() { + return [[assert.type.any], [Function]]; }}); - Object.defineProperty(AstVisitor.prototype.visitPrefixNot, "parameters", {get: function() { - return [[PrefixNot]]; + Object.defineProperty(ControlGroup.prototype._included, "parameters", {get: function() { + return [[assert.type.string]]; }}); - AstTransformer = (function() { - function AstTransformer() {} - return ($traceurRuntime.createClass)(AstTransformer, { - visitImplicitReceiver: function(ast) { - assert.argumentTypes(ast, ImplicitReceiver); - return ast; - }, - visitInterpolation: function(ast) { - assert.argumentTypes(ast, Interpolation); - return new Interpolation(ast.strings, this.visitAll(ast.expressions)); - }, - visitLiteralPrimitive: function(ast) { - assert.argumentTypes(ast, LiteralPrimitive); - return new LiteralPrimitive(ast.value); - }, - visitAccessMember: function(ast) { - assert.argumentTypes(ast, AccessMember); - return new AccessMember(ast.receiver.visit(this), ast.name, ast.getter, ast.setter); - }, - visitMethodCall: function(ast) { - assert.argumentTypes(ast, MethodCall); - return new MethodCall(ast.receiver.visit(this), ast.name, ast.fn, this.visitAll(ast.args)); - }, - visitFunctionCall: function(ast) { - assert.argumentTypes(ast, FunctionCall); - return new FunctionCall(ast.target.visit(this), this.visitAll(ast.args)); - }, - visitLiteralArray: function(ast) { - assert.argumentTypes(ast, LiteralArray); - return new LiteralArray(this.visitAll(ast.expressions)); + ControlArray = (function($__super) { + function ControlArray(controls) { + var validator = arguments[1] !== (void 0) ? arguments[1] : Validators.array; + $traceurRuntime.superConstructor(ControlArray).call(this, validator); + this.controls = controls; + this._valueChanges = new EventEmitter(); + this._setParentForControls(); + this._setValueErrorsStatus(); + } + return ($traceurRuntime.createClass)(ControlArray, { + at: function(index) { + return this.controls[index]; }, - visitLiteralMap: function(ast) { - assert.argumentTypes(ast, LiteralMap); - return new LiteralMap(ast.keys, this.visitAll(ast.values)); + push: function(control) { + ListWrapper.push(this.controls, control); + control.setParent(this); + this._updateValue(); }, - visitBinary: function(ast) { - assert.argumentTypes(ast, Binary); - return new Binary(ast.operation, ast.left.visit(this), ast.right.visit(this)); + insert: function(index, control) { + ListWrapper.insert(this.controls, index, control); + control.setParent(this); + this._updateValue(); }, - visitPrefixNot: function(ast) { - assert.argumentTypes(ast, PrefixNot); - return new PrefixNot(ast.expression.visit(this)); + removeAt: function(index) { + ListWrapper.removeAt(this.controls, index); + this._updateValue(); }, - visitConditional: function(ast) { - assert.argumentTypes(ast, Conditional); - return new Conditional(ast.condition.visit(this), ast.trueExp.visit(this), ast.falseExp.visit(this)); + get length() { + return this.controls.length; }, - visitPipe: function(ast) { - assert.argumentTypes(ast, Pipe); - return new Pipe(ast.exp.visit(this), ast.name, this.visitAll(ast.args), ast.inBinding); + _updateValue: function() { + this._setValueErrorsStatus(); + this._pristine = false; + ObservableWrapper.callNext(this._valueChanges, this._value); + this._updateParent(); }, - visitKeyedAccess: function(ast) { - assert.argumentTypes(ast, KeyedAccess); - return new KeyedAccess(ast.obj.visit(this), ast.key.visit(this)); + _setParentForControls: function() { + var $__0 = this; + ListWrapper.forEach(this.controls, (function(control) { + control.setParent($__0); + })); }, - visitAll: function(asts) { - assert.argumentTypes(asts, List); - var res = ListWrapper.createFixedSize(asts.length); - for (var i = 0; i < asts.length; ++i) { - res[i] = asts[i].visit(this); - } - return res; + _setValueErrorsStatus: function() { + this._value = ListWrapper.map(this.controls, (function(c) { + return c.value; + })); + this._errors = this.validator(this); + this._status = isPresent(this._errors) ? INVALID : VALID; } - }, {}); - }()); - $__export("AstTransformer", AstTransformer); - Object.defineProperty(AstTransformer.prototype.visitImplicitReceiver, "parameters", {get: function() { - return [[ImplicitReceiver]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitInterpolation, "parameters", {get: function() { - return [[Interpolation]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitLiteralPrimitive, "parameters", {get: function() { - return [[LiteralPrimitive]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitAccessMember, "parameters", {get: function() { - return [[AccessMember]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitMethodCall, "parameters", {get: function() { - return [[MethodCall]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitFunctionCall, "parameters", {get: function() { - return [[FunctionCall]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitLiteralArray, "parameters", {get: function() { - return [[LiteralArray]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitLiteralMap, "parameters", {get: function() { - return [[LiteralMap]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitBinary, "parameters", {get: function() { - return [[Binary]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitPrefixNot, "parameters", {get: function() { - return [[PrefixNot]]; - }}); - Object.defineProperty(AstTransformer.prototype.visitConditional, "parameters", {get: function() { - return [[Conditional]]; + }, {}, $__super); + }(AbstractControl)); + $__export("ControlArray", ControlArray); + Object.defineProperty(ControlArray, "parameters", {get: function() { + return [[assert.genericType(List, AbstractControl)], [Function]]; }}); - Object.defineProperty(AstTransformer.prototype.visitPipe, "parameters", {get: function() { - return [[Pipe]]; + Object.defineProperty(ControlArray.prototype.at, "parameters", {get: function() { + return [[assert.type.number]]; }}); - Object.defineProperty(AstTransformer.prototype.visitKeyedAccess, "parameters", {get: function() { - return [[KeyedAccess]]; + Object.defineProperty(ControlArray.prototype.push, "parameters", {get: function() { + return [[AbstractControl]]; }}); - Object.defineProperty(AstTransformer.prototype.visitAll, "parameters", {get: function() { - return [[List]]; + Object.defineProperty(ControlArray.prototype.insert, "parameters", {get: function() { + return [[assert.type.number], [AbstractControl]]; }}); - _evalListCache = [[], [0], [0, 0], [0, 0, 0], [0, 0, 0, 0], [0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 0, 0]]; - Object.defineProperty(evalList, "parameters", {get: function() { - return [[], [], [List]]; + Object.defineProperty(ControlArray.prototype.removeAt, "parameters", {get: function() { + return [[assert.type.number]]; }}); } }; }); -System.register("angular2/src/reflection/reflection", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/reflection/reflector", "angular2/src/reflection/reflection_capabilities"], function($__export) { +System.register("angular2/src/di/decorators", ["angular2/src/di/annotations", "angular2/src/util/decorators"], function($__export) { "use strict"; - var __moduleName = "angular2/src/reflection/reflection"; - var Type, - isPresent, - List, - ListWrapper, - Reflector, - ReflectionCapabilities, - reflector; + var __moduleName = "angular2/src/di/decorators"; + var InjectAnnotation, + InjectPromiseAnnotation, + InjectLazyAnnotation, + OptionalAnnotation, + InjectableAnnotation, + makeDecorator, + makeParamDecorator, + Inject, + InjectPromise, + InjectLazy, + Optional, + Injectable; return { setters: [function($__m) { - Type = $__m.Type; - isPresent = $__m.isPresent; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - Reflector = $__m.Reflector; - $__export("Reflector", $__m.Reflector); - }, function($__m) { - ReflectionCapabilities = $__m.ReflectionCapabilities; + InjectAnnotation = $__m.InjectAnnotation; + InjectPromiseAnnotation = $__m.InjectPromiseAnnotation; + InjectLazyAnnotation = $__m.InjectLazyAnnotation; + OptionalAnnotation = $__m.OptionalAnnotation; + InjectableAnnotation = $__m.InjectableAnnotation; + }, function($__m) { + makeDecorator = $__m.makeDecorator; + makeParamDecorator = $__m.makeParamDecorator; }], execute: function() { - reflector = new Reflector(new ReflectionCapabilities()); - $__export("reflector", reflector); + Inject = makeParamDecorator(InjectAnnotation); + $__export("Inject", Inject); + InjectPromise = makeParamDecorator(InjectPromiseAnnotation); + $__export("InjectPromise", InjectPromise); + InjectLazy = makeParamDecorator(InjectLazyAnnotation); + $__export("InjectLazy", InjectLazy); + Optional = makeParamDecorator(OptionalAnnotation); + $__export("Optional", Optional); + Injectable = makeDecorator(InjectableAnnotation); + $__export("Injectable", Injectable); } }; }); -System.register("angular2/src/change_detection/binding_record", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/reflection/types", "angular2/src/change_detection/parser/ast", "angular2/src/change_detection/directive_record"], function($__export) { +System.register("angular2/src/reflection/reflection", ["angular2/src/reflection/reflector", "angular2/src/reflection/reflection_capabilities"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/binding_record"; - var assert, - isPresent, - isBlank, - SetterFn, - AST, - DirectiveIndex, - DirectiveRecord, - DIRECTIVE, - ELEMENT, - TEXT_NODE, - BindingRecord; + var __moduleName = "angular2/src/reflection/reflection"; + var Reflector, + ReflectionCapabilities, + __esModule, + reflector; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - }, function($__m) { - SetterFn = $__m.SetterFn; - }, function($__m) { - AST = $__m.AST; + Reflector = $__m.Reflector; + $__export("Reflector", $__m.Reflector); }, function($__m) { - DirectiveIndex = $__m.DirectiveIndex; - DirectiveRecord = $__m.DirectiveRecord; - }], - execute: function() { - DIRECTIVE = "directive"; - ELEMENT = "element"; - TEXT_NODE = "textNode"; - BindingRecord = (function() { - function BindingRecord(mode, implicitReceiver, ast, elementIndex, propertyName, setter, directiveRecord) { - assert.argumentTypes(mode, assert.type.string, implicitReceiver, assert.type.any, ast, AST, elementIndex, assert.type.number, propertyName, assert.type.string, setter, SetterFn, directiveRecord, DirectiveRecord); - this.mode = mode; - this.implicitReceiver = implicitReceiver; - this.ast = ast; - this.elementIndex = elementIndex; - this.propertyName = propertyName; - this.setter = setter; - this.directiveRecord = directiveRecord; - } - return ($traceurRuntime.createClass)(BindingRecord, { - callOnChange: function() { - return isPresent(this.directiveRecord) && this.directiveRecord.callOnChange; - }, - isOnPushChangeDetection: function() { - return isPresent(this.directiveRecord) && this.directiveRecord.isOnPushChangeDetection(); - }, - isDirective: function() { - return this.mode === DIRECTIVE; - }, - isElement: function() { - return this.mode === ELEMENT; - }, - isTextNode: function() { - return this.mode === TEXT_NODE; - } - }, { - createForDirective: function(ast, propertyName, setter, directiveRecord) { - assert.argumentTypes(ast, AST, propertyName, assert.type.string, setter, SetterFn, directiveRecord, DirectiveRecord); - return new BindingRecord(DIRECTIVE, 0, ast, 0, propertyName, setter, directiveRecord); - }, - createForElement: function(ast, elementIndex, propertyName) { - assert.argumentTypes(ast, AST, elementIndex, assert.type.number, propertyName, assert.type.string); - return new BindingRecord(ELEMENT, 0, ast, elementIndex, propertyName, null, null); - }, - createForHostProperty: function(directiveIndex, ast, propertyName) { - assert.argumentTypes(directiveIndex, DirectiveIndex, ast, AST, propertyName, assert.type.string); - return new BindingRecord(ELEMENT, directiveIndex, ast, directiveIndex.elementIndex, propertyName, null, null); - }, - createForTextNode: function(ast, elementIndex) { - assert.argumentTypes(ast, AST, elementIndex, assert.type.number); - return new BindingRecord(TEXT_NODE, 0, ast, elementIndex, null, null, null); - } - }); - }()); - $__export("BindingRecord", BindingRecord); - Object.defineProperty(BindingRecord, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any], [AST], [assert.type.number], [assert.type.string], [SetterFn], [DirectiveRecord]]; - }}); - Object.defineProperty(BindingRecord.createForDirective, "parameters", {get: function() { - return [[AST], [assert.type.string], [SetterFn], [DirectiveRecord]]; - }}); - Object.defineProperty(BindingRecord.createForElement, "parameters", {get: function() { - return [[AST], [assert.type.number], [assert.type.string]]; - }}); - Object.defineProperty(BindingRecord.createForHostProperty, "parameters", {get: function() { - return [[DirectiveIndex], [AST], [assert.type.string]]; - }}); - Object.defineProperty(BindingRecord.createForTextNode, "parameters", {get: function() { - return [[AST], [assert.type.number]]; - }}); + ReflectionCapabilities = $__m.ReflectionCapabilities; + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + reflector = new Reflector(new ReflectionCapabilities()); + $__export("reflector", reflector); } }; }); -System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/abstract_change_detector", "angular2/src/change_detection/binding_record", "angular2/src/change_detection/pipes/pipe_registry", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/proto_record", "angular2/src/change_detection/exceptions"], function($__export) { +System.register("angular2/src/change_detection/dynamic_change_detector", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/abstract_change_detector", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/proto_record", "angular2/src/change_detection/exceptions"], function($__export) { "use strict"; var __moduleName = "angular2/src/change_detection/dynamic_change_detector"; - var assert, - isPresent, + var isPresent, isBlank, BaseException, FunctionWrapper, - List, ListWrapper, - MapWrapper, - StringMapWrapper, AbstractChangeDetector, - BindingRecord, - PipeRegistry, ChangeDetectionUtil, uninitialized, - ProtoRecord, RECORD_TYPE_SELF, RECORD_TYPE_PROPERTY, RECORD_TYPE_LOCAL, @@ -24360,8 +19850,8 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ RECORD_TYPE_PIPE, RECORD_TYPE_BINDING_PIPE, RECORD_TYPE_INTERPOLATE, - ExpressionChangedAfterItHasBeenChecked, ChangeDetectionError, + __esModule, DynamicChangeDetector; function isSame(a, b) { if (a === b) @@ -24374,28 +19864,18 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { isPresent = $__m.isPresent; isBlank = $__m.isBlank; BaseException = $__m.BaseException; FunctionWrapper = $__m.FunctionWrapper; }, function($__m) { - List = $__m.List; ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - StringMapWrapper = $__m.StringMapWrapper; }, function($__m) { AbstractChangeDetector = $__m.AbstractChangeDetector; - }, function($__m) { - BindingRecord = $__m.BindingRecord; - }, function($__m) { - PipeRegistry = $__m.PipeRegistry; }, function($__m) { ChangeDetectionUtil = $__m.ChangeDetectionUtil; uninitialized = $__m.uninitialized; }, function($__m) { - ProtoRecord = $__m.ProtoRecord; RECORD_TYPE_SELF = $__m.RECORD_TYPE_SELF; RECORD_TYPE_PROPERTY = $__m.RECORD_TYPE_PROPERTY; RECORD_TYPE_LOCAL = $__m.RECORD_TYPE_LOCAL; @@ -24408,33 +19888,32 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ RECORD_TYPE_BINDING_PIPE = $__m.RECORD_TYPE_BINDING_PIPE; RECORD_TYPE_INTERPOLATE = $__m.RECORD_TYPE_INTERPOLATE; }, function($__m) { - ExpressionChangedAfterItHasBeenChecked = $__m.ExpressionChangedAfterItHasBeenChecked; ChangeDetectionError = $__m.ChangeDetectionError; }], execute: function() { + __esModule = true; + $__export("__esModule", __esModule); DynamicChangeDetector = (function($__super) { - function DynamicChangeDetector(changeControlStrategy, dispatcher, pipeRegistry, protoRecords, directiveRecords) { - assert.argumentTypes(changeControlStrategy, assert.type.string, dispatcher, assert.type.any, pipeRegistry, PipeRegistry, protoRecords, assert.genericType(List, ProtoRecord), directiveRecords, List); + function DynamicChangeDetector(changeControlStrategy, dispatcher, pipeRegistry, protos, directiveRecords) { $traceurRuntime.superConstructor(DynamicChangeDetector).call(this); + this.changeControlStrategy = changeControlStrategy; this.dispatcher = dispatcher; this.pipeRegistry = pipeRegistry; - this.values = ListWrapper.createFixedSize(protoRecords.length + 1); - this.pipes = ListWrapper.createFixedSize(protoRecords.length + 1); - this.prevContexts = ListWrapper.createFixedSize(protoRecords.length + 1); - this.changes = ListWrapper.createFixedSize(protoRecords.length + 1); + this.protos = protos; + this.directiveRecords = directiveRecords; + this.values = ListWrapper.createFixedSize(protos.length + 1); + this.pipes = ListWrapper.createFixedSize(protos.length + 1); + this.prevContexts = ListWrapper.createFixedSize(protos.length + 1); + this.changes = ListWrapper.createFixedSize(protos.length + 1); ListWrapper.fill(this.values, uninitialized); ListWrapper.fill(this.pipes, null); ListWrapper.fill(this.prevContexts, uninitialized); ListWrapper.fill(this.changes, false); this.locals = null; this.directives = null; - this.protos = protoRecords; - this.directiveRecords = directiveRecords; - this.changeControlStrategy = changeControlStrategy; } return ($traceurRuntime.createClass)(DynamicChangeDetector, { hydrate: function(context, locals, directives) { - assert.argumentTypes(context, assert.type.any, locals, assert.type.any, directives, assert.type.any); this.mode = ChangeDetectionUtil.changeDetectionMode(this.changeControlStrategy); this.values[0] = context; this.locals = locals; @@ -24456,21 +19935,18 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ } }, hydrated: function() { - return assert.returnType((this.values[0] !== uninitialized), assert.type.boolean); + return this.values[0] !== uninitialized; }, detectChangesInRecords: function(throwOnChange) { - assert.argumentTypes(throwOnChange, assert.type.boolean); - var protos = assert.type(this.protos, assert.genericType(List, ProtoRecord)); + var protos = this.protos; var changes = null; var isChanged = false; for (var i = 0; i < protos.length; ++i) { - var proto = assert.type(protos[i], ProtoRecord); + var proto = protos[i]; var bindingRecord = proto.bindingRecord; var directiveRecord = bindingRecord.directiveRecord; - var change = this._check(proto); + var change = this._check(proto, throwOnChange); if (isPresent(change)) { - if (throwOnChange) - ChangeDetectionUtil.throwOnChange(proto, change); this._updateDirectiveOrElement(change, bindingRecord); isChanged = true; changes = this._addChange(bindingRecord, change, changes); @@ -24505,7 +19981,6 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ } }, _addChange: function(bindingRecord, change, changes) { - assert.argumentTypes(bindingRecord, BindingRecord, change, assert.type.any, changes, assert.type.any); if (bindingRecord.callOnChange()) { return ChangeDetectionUtil.addChange(changes, bindingRecord.propertyName, change); } else { @@ -24518,20 +19993,18 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ _getDetectorFor: function(directiveIndex) { return this.directives.getDetectorFor(directiveIndex); }, - _check: function(proto) { - assert.argumentTypes(proto, ProtoRecord); + _check: function(proto, throwOnChange) { try { if (proto.mode === RECORD_TYPE_PIPE || proto.mode === RECORD_TYPE_BINDING_PIPE) { - return this._pipeCheck(proto); + return this._pipeCheck(proto, throwOnChange); } else { - return this._referenceCheck(proto); + return this._referenceCheck(proto, throwOnChange); } } catch (e) { throw new ChangeDetectionError(proto, e); } }, - _referenceCheck: function(proto) { - assert.argumentTypes(proto, ProtoRecord); + _referenceCheck: function(proto, throwOnChange) { if (this._pureFuncAndArgsDidNotChange(proto)) { this._setChanged(proto, false); return null; @@ -24539,11 +20012,16 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ var prevValue = this._readSelf(proto); var currValue = this._calculateCurrValue(proto); if (!isSame(prevValue, currValue)) { - this._writeSelf(proto, currValue); - this._setChanged(proto, true); if (proto.lastInBinding) { - return ChangeDetectionUtil.simpleChange(prevValue, currValue); + var change = ChangeDetectionUtil.simpleChange(prevValue, currValue); + if (throwOnChange) + ChangeDetectionUtil.throwOnChange(proto, change); + this._writeSelf(proto, currValue); + this._setChanged(proto, true); + return change; } else { + this._writeSelf(proto, currValue); + this._setChanged(proto, true); return null; } } else { @@ -24552,7 +20030,6 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ } }, _calculateCurrValue: function(proto) { - assert.argumentTypes(proto, ProtoRecord); switch (proto.mode) { case RECORD_TYPE_SELF: return this._readContext(proto); @@ -24579,19 +20056,23 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ throw new BaseException(("Unknown operation " + proto.mode)); } }, - _pipeCheck: function(proto) { - assert.argumentTypes(proto, ProtoRecord); + _pipeCheck: function(proto, throwOnChange) { var context = this._readContext(proto); var pipe = this._pipeFor(proto, context); var prevValue = this._readSelf(proto); - var newValue = pipe.transform(context); - if (!isSame(prevValue, newValue)) { - newValue = ChangeDetectionUtil.unwrapValue(newValue); - this._writeSelf(proto, newValue); - this._setChanged(proto, true); + var currValue = pipe.transform(context); + if (!isSame(prevValue, currValue)) { + currValue = ChangeDetectionUtil.unwrapValue(currValue); if (proto.lastInBinding) { - return ChangeDetectionUtil.simpleChange(prevValue, newValue); + var change = ChangeDetectionUtil.simpleChange(prevValue, currValue); + if (throwOnChange) + ChangeDetectionUtil.throwOnChange(proto, change); + this._writeSelf(proto, currValue); + this._setChanged(proto, true); + return change; } else { + this._writeSelf(proto, currValue); + this._setChanged(proto, true); return null; } } else { @@ -24600,7 +20081,6 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ } }, _pipeFor: function(proto, context) { - assert.argumentTypes(proto, ProtoRecord, context, assert.type.any); var storedPipe = this._readPipe(proto); if (isPresent(storedPipe) && storedPipe.supports(context)) { return storedPipe; @@ -24614,7 +20094,6 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ return pipe; }, _readContext: function(proto) { - assert.argumentTypes(proto, ProtoRecord); if (proto.contextIndex == -1) { return this._getDirectiveFor(proto.directiveIndex); } else { @@ -24623,41 +20102,33 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ return this.values[proto.contextIndex]; }, _readSelf: function(proto) { - assert.argumentTypes(proto, ProtoRecord); return this.values[proto.selfIndex]; }, _writeSelf: function(proto, value) { - assert.argumentTypes(proto, ProtoRecord, value, assert.type.any); this.values[proto.selfIndex] = value; }, _readPipe: function(proto) { - assert.argumentTypes(proto, ProtoRecord); return this.pipes[proto.selfIndex]; }, _writePipe: function(proto, value) { - assert.argumentTypes(proto, ProtoRecord, value, assert.type.any); this.pipes[proto.selfIndex] = value; }, _setChanged: function(proto, value) { - assert.argumentTypes(proto, ProtoRecord, value, assert.type.boolean); this.changes[proto.selfIndex] = value; }, _pureFuncAndArgsDidNotChange: function(proto) { - assert.argumentTypes(proto, ProtoRecord); - return assert.returnType((proto.isPureFunction() && !this._argsChanged(proto)), assert.type.boolean); + return proto.isPureFunction() && !this._argsChanged(proto); }, _argsChanged: function(proto) { - assert.argumentTypes(proto, ProtoRecord); var args = proto.args; for (var i = 0; i < args.length; ++i) { if (this.changes[args[i]]) { - return assert.returnType((true), assert.type.boolean); + return true; } } - return assert.returnType((false), assert.type.boolean); + return false; }, _readArgs: function(proto) { - assert.argumentTypes(proto, ProtoRecord); var res = ListWrapper.createFixedSize(proto.args.length); var args = proto.args; for (var i = 0; i < args.length; ++i) { @@ -24668,633 +20139,526 @@ System.register("angular2/src/change_detection/dynamic_change_detector", ["rtts_ }, {}, $__super); }(AbstractChangeDetector)); $__export("DynamicChangeDetector", DynamicChangeDetector); - Object.defineProperty(DynamicChangeDetector, "parameters", {get: function() { - return [[assert.type.string], [assert.type.any], [PipeRegistry], [assert.genericType(List, ProtoRecord)], [List]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype.hydrate, "parameters", {get: function() { - return [[assert.type.any], [assert.type.any], [assert.type.any]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype.detectChangesInRecords, "parameters", {get: function() { - return [[assert.type.boolean]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._addChange, "parameters", {get: function() { - return [[BindingRecord], [], []]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._check, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._referenceCheck, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._calculateCurrValue, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._pipeCheck, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._pipeFor, "parameters", {get: function() { - return [[ProtoRecord], []]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._readContext, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._readSelf, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._writeSelf, "parameters", {get: function() { - return [[ProtoRecord], []]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._readPipe, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._writePipe, "parameters", {get: function() { - return [[ProtoRecord], []]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._setChanged, "parameters", {get: function() { - return [[ProtoRecord], [assert.type.boolean]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._pureFuncAndArgsDidNotChange, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._argsChanged, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); - Object.defineProperty(DynamicChangeDetector.prototype._readArgs, "parameters", {get: function() { - return [[ProtoRecord]]; - }}); } }; }); -System.register("angular2/src/render/dom/view/view", ["rtts_assert/rtts_assert", "angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/render/dom/view/view_container", "angular2/src/render/dom/view/proto_view", "angular2/src/render/dom/shadow_dom/light_dom", "angular2/src/render/dom/shadow_dom/content_tag"], function($__export) { +System.register("angular2/src/change_detection/pipes/observable_pipe", ["angular2/src/facade/async", "angular2/src/facade/lang", "angular2/src/change_detection/pipes/pipe"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/view/view"; - var assert, - DOM, - ListWrapper, - MapWrapper, - Map, - StringMapWrapper, - List, - int, - isPresent, + var __moduleName = "angular2/src/change_detection/pipes/observable_pipe"; + var __decorate, + __metadata, + ObservableWrapper, isBlank, - BaseException, - ViewContainer, - RenderProtoView, - LightDom, - Content, - NG_BINDING_CLASS, - RenderView; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - Map = $__m.Map; - StringMapWrapper = $__m.StringMapWrapper; - List = $__m.List; - }, function($__m) { - int = $__m.int; - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - }, function($__m) { - ViewContainer = $__m.ViewContainer; - }, function($__m) { - RenderProtoView = $__m.RenderProtoView; - }, function($__m) { - LightDom = $__m.LightDom; - }, function($__m) { - Content = $__m.Content; - }], - execute: function() { - NG_BINDING_CLASS = 'ng-binding'; - RenderView = (function() { - function RenderView(proto, rootNodes, boundTextNodes, boundElements, contentTags) { - assert.argumentTypes(proto, RenderProtoView, rootNodes, List, boundTextNodes, List, boundElements, List, contentTags, List); - this.proto = proto; - this.rootNodes = rootNodes; - this.boundTextNodes = boundTextNodes; - this.boundElements = boundElements; - this.viewContainers = ListWrapper.createFixedSize(boundElements.length); - this.contentTags = contentTags; - this.lightDoms = ListWrapper.createFixedSize(boundElements.length); - ListWrapper.fill(this.lightDoms, null); - this.componentChildViews = ListWrapper.createFixedSize(boundElements.length); - this.hostLightDom = null; - this.hydrated = false; - this.eventHandlerRemovers = []; - this.imperativeHostViews = []; - } - return ($traceurRuntime.createClass)(RenderView, { - getDirectParentLightDom: function(boundElementIndex) { - assert.argumentTypes(boundElementIndex, assert.type.number); - var binder = this.proto.elementBinders[boundElementIndex]; - var destLightDom = null; - if (binder.parentIndex !== -1 && binder.distanceToParent === 1) { - destLightDom = this.lightDoms[binder.parentIndex]; - } - return destLightDom; - }, - getOrCreateViewContainer: function(binderIndex) { - var vc = this.viewContainers[binderIndex]; - if (isBlank(vc)) { - vc = new ViewContainer(this, binderIndex); - this.viewContainers[binderIndex] = vc; - } - return vc; - }, - setElementProperty: function(elementIndex, propertyName, value) { - assert.argumentTypes(elementIndex, assert.type.number, propertyName, assert.type.string, value, assert.type.any); - var setter = MapWrapper.get(this.proto.elementBinders[elementIndex].propertySetters, propertyName); - setter(this.boundElements[elementIndex], value); - }, - setText: function(textIndex, value) { - assert.argumentTypes(textIndex, assert.type.number, value, assert.type.string); - DOM.setText(this.boundTextNodes[textIndex], value); - }, - getViewContainer: function(index) { - assert.argumentTypes(index, assert.type.number); - return assert.returnType((this.viewContainers[index]), ViewContainer); - }, - setEventDispatcher: function(dispatcher) { - assert.argumentTypes(dispatcher, assert.type.any); - this._eventDispatcher = dispatcher; - }, - dispatchEvent: function(elementIndex, eventName, event) { - var allowDefaultBehavior = true; - if (isPresent(this._eventDispatcher)) { - var evalLocals = MapWrapper.create(); - MapWrapper.set(evalLocals, '$event', event); - allowDefaultBehavior = this._eventDispatcher.dispatchEvent(elementIndex, eventName, evalLocals); - if (!allowDefaultBehavior) { - event.preventDefault(); - } - } - return assert.returnType((allowDefaultBehavior), assert.type.boolean); - } - }, {}); - }()); - $__export("RenderView", RenderView); - Object.defineProperty(RenderView, "parameters", {get: function() { - return [[RenderProtoView], [List], [List], [List], [List]]; - }}); - Object.defineProperty(RenderView.prototype.getDirectParentLightDom, "parameters", {get: function() { - return [[assert.type.number]]; - }}); - Object.defineProperty(RenderView.prototype.setElementProperty, "parameters", {get: function() { - return [[assert.type.number], [assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(RenderView.prototype.setText, "parameters", {get: function() { - return [[assert.type.number], [assert.type.string]]; - }}); - Object.defineProperty(RenderView.prototype.getViewContainer, "parameters", {get: function() { - return [[assert.type.number]]; - }}); - Object.defineProperty(RenderView.prototype.setEventDispatcher, "parameters", {get: function() { - return [[assert.type.any]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/view/view_factory", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/shadow_dom/content_tag", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/events/event_manager", "angular2/src/render/dom/view/proto_view", "angular2/src/render/dom/view/view", "angular2/src/render/dom/util"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/view/view_factory"; - var assert, - OpaqueToken, - Inject, - Injectable, - int, isPresent, - isBlank, - BaseException, - ListWrapper, - MapWrapper, - Map, - StringMapWrapper, - List, - DOM, - Content, - ShadowDomStrategy, - EventManager, - pvModule, - viewModule, - NG_BINDING_CLASS_SELECTOR, - NG_BINDING_CLASS, - VIEW_POOL_CAPACITY, - ViewFactory; + CONST, + Pipe, + WrappedValue, + PipeFactory, + __esModule, + ObservablePipe, + ObservablePipeFactory; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - OpaqueToken = $__m.OpaqueToken; - Inject = $__m.Inject; - Injectable = $__m.Injectable; + ObservableWrapper = $__m.ObservableWrapper; }, function($__m) { - int = $__m.int; - isPresent = $__m.isPresent; isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - Map = $__m.Map; - StringMapWrapper = $__m.StringMapWrapper; - List = $__m.List; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - Content = $__m.Content; - }, function($__m) { - ShadowDomStrategy = $__m.ShadowDomStrategy; - }, function($__m) { - EventManager = $__m.EventManager; - }, function($__m) { - pvModule = $__m; - }, function($__m) { - viewModule = $__m; + isPresent = $__m.isPresent; + CONST = $__m.CONST; }, function($__m) { - NG_BINDING_CLASS_SELECTOR = $__m.NG_BINDING_CLASS_SELECTOR; - NG_BINDING_CLASS = $__m.NG_BINDING_CLASS; + Pipe = $__m.Pipe; + WrappedValue = $__m.WrappedValue; + PipeFactory = $__m.PipeFactory; }], execute: function() { - VIEW_POOL_CAPACITY = 'render.ViewFactory.viewPoolCapacity'; - $__export("VIEW_POOL_CAPACITY", VIEW_POOL_CAPACITY); - ViewFactory = (function() { - function ViewFactory(poolCapacityPerProtoView, eventManager, shadowDomStrategy) { - assert.argumentTypes(poolCapacityPerProtoView, assert.type.any, eventManager, EventManager, shadowDomStrategy, ShadowDomStrategy); - this._poolCapacityPerProtoView = poolCapacityPerProtoView; - this._pooledViewsPerProtoView = MapWrapper.create(); - this._eventManager = eventManager; - this._shadowDomStrategy = shadowDomStrategy; + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); } - return ($traceurRuntime.createClass)(ViewFactory, { - createInPlaceHostView: function(hostElementSelector, hostProtoView) { - assert.argumentTypes(hostElementSelector, assert.type.any, hostProtoView, pvModule.RenderProtoView); - return assert.returnType((this._createView(hostProtoView, hostElementSelector)), viewModule.RenderView); - }, - getView: function(protoView) { - assert.argumentTypes(protoView, pvModule.RenderProtoView); - var pooledViews = MapWrapper.get(this._pooledViewsPerProtoView, protoView); - if (isPresent(pooledViews) && pooledViews.length > 0) { - return assert.returnType((ListWrapper.removeLast(pooledViews)), viewModule.RenderView); - } - return assert.returnType((this._createView(protoView, null)), viewModule.RenderView); - }, - returnView: function(view) { - assert.argumentTypes(view, viewModule.RenderView); - if (view.hydrated) { - throw new BaseException('View is still hydrated'); - } - var protoView = view.proto; - var pooledViews = MapWrapper.get(this._pooledViewsPerProtoView, protoView); - if (isBlank(pooledViews)) { - pooledViews = []; - MapWrapper.set(this._pooledViewsPerProtoView, protoView, pooledViews); - } - if (pooledViews.length < this._poolCapacityPerProtoView) { - ListWrapper.push(pooledViews, view); - } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + ObservablePipe = (function($__super) { + function ObservablePipe(ref) { + $traceurRuntime.superConstructor(ObservablePipe).call(this); + this._ref = ref; + this._latestValue = null; + this._latestReturnedValue = null; + this._subscription = null; + this._observable = null; + } + return ($traceurRuntime.createClass)(ObservablePipe, { + supports: function(obs) { + return ObservableWrapper.isObservable(obs); }, - _createView: function(protoView, inplaceElement) { - assert.argumentTypes(protoView, pvModule.RenderProtoView, inplaceElement, assert.type.any); - if (isPresent(protoView.imperativeRendererId)) { - return assert.returnType((new viewModule.RenderView(protoView, [], [], [], [])), viewModule.RenderView); - } - var rootElementClone = isPresent(inplaceElement) ? inplaceElement : DOM.importIntoDoc(protoView.element); - var elementsWithBindingsDynamic; - if (protoView.isTemplateElement) { - elementsWithBindingsDynamic = DOM.querySelectorAll(DOM.content(rootElementClone), NG_BINDING_CLASS_SELECTOR); - } else { - elementsWithBindingsDynamic = DOM.getElementsByClassName(rootElementClone, NG_BINDING_CLASS); - } - var elementsWithBindings = ListWrapper.createFixedSize(elementsWithBindingsDynamic.length); - for (var binderIdx = 0; binderIdx < elementsWithBindingsDynamic.length; ++binderIdx) { - elementsWithBindings[binderIdx] = elementsWithBindingsDynamic[binderIdx]; - } - var viewRootNodes; - if (protoView.isTemplateElement) { - var childNode = DOM.firstChild(DOM.content(rootElementClone)); - viewRootNodes = []; - while (childNode != null) { - ListWrapper.push(viewRootNodes, childNode); - childNode = DOM.nextSibling(childNode); - } - } else { - viewRootNodes = [rootElementClone]; + onDestroy: function() { + if (isPresent(this._subscription)) { + this._dispose(); } - var binders = protoView.elementBinders; - var boundTextNodes = []; - var boundElements = ListWrapper.createFixedSize(binders.length); - var contentTags = ListWrapper.createFixedSize(binders.length); - for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { - var binder = binders[binderIdx]; - var element = void 0; - if (binderIdx === 0 && protoView.rootBindingOffset === 1) { - element = rootElementClone; - } else { - element = elementsWithBindings[binderIdx - protoView.rootBindingOffset]; - } - boundElements[binderIdx] = element; - var childNodes = DOM.childNodes(DOM.templateAwareRoot(element)); - var textNodeIndices = binder.textNodeIndices; - for (var i = 0; i < textNodeIndices.length; i++) { - ListWrapper.push(boundTextNodes, childNodes[textNodeIndices[i]]); - } - var contentTag = null; - if (isPresent(binder.contentTagSelector)) { - contentTag = new Content(element, binder.contentTagSelector); - } - contentTags[binderIdx] = contentTag; + }, + transform: function(obs) { + if (isBlank(this._subscription)) { + this._subscribe(obs); + return null; } - var view = new viewModule.RenderView(protoView, viewRootNodes, boundTextNodes, boundElements, contentTags); - for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { - var binder = binders[binderIdx]; - var element = boundElements[binderIdx]; - if (binder.hasStaticComponent()) { - var childView = this._createView(binder.nestedProtoView, null); - ViewFactory.setComponentView(this._shadowDomStrategy, view, binderIdx, childView); - } - if (isPresent(binder.eventLocals) && isPresent(binder.localEvents)) { - for (var i = 0; i < binder.localEvents.length; i++) { - this._createEventListener(view, element, binderIdx, binder.localEvents[i].name, binder.eventLocals); - } - } + if (obs !== this._observable) { + this._dispose(); + return this.transform(obs); + } + if (this._latestValue === this._latestReturnedValue) { + return this._latestReturnedValue; + } else { + this._latestReturnedValue = this._latestValue; + return WrappedValue.wrap(this._latestValue); } - return assert.returnType((view), viewModule.RenderView); }, - _createEventListener: function(view, element, elementIndex, eventName, eventLocals) { - this._eventManager.addEventListener(element, eventName, (function(event) { - view.dispatchEvent(elementIndex, eventName, event); + _subscribe: function(obs) { + var $__0 = this; + this._observable = obs; + this._subscription = ObservableWrapper.subscribe(obs, (function(value) { + $__0._updateLatestValue(value); + }), (function(e) { + throw e; })); + }, + _dispose: function() { + ObservableWrapper.dispose(this._subscription); + this._latestValue = null; + this._latestReturnedValue = null; + this._subscription = null; + this._observable = null; + }, + _updateLatestValue: function(value) { + this._latestValue = value; + this._ref.requestCheck(); } - }, {setComponentView: function(shadowDomStrategy, hostView, elementIndex, componentView) { - assert.argumentTypes(shadowDomStrategy, ShadowDomStrategy, hostView, viewModule.RenderView, elementIndex, assert.type.number, componentView, viewModule.RenderView); - var element = hostView.boundElements[elementIndex]; - var lightDom = shadowDomStrategy.constructLightDom(hostView, componentView, element); - shadowDomStrategy.attachTemplate(element, componentView); - hostView.lightDoms[elementIndex] = lightDom; - hostView.componentChildViews[elementIndex] = componentView; - }}); - }()); - $__export("ViewFactory", ViewFactory); - Object.defineProperty(ViewFactory, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(ViewFactory, "parameters", {get: function() { - return [[new Inject(VIEW_POOL_CAPACITY)], [EventManager], [ShadowDomStrategy]]; - }}); - Object.defineProperty(ViewFactory.prototype.createInPlaceHostView, "parameters", {get: function() { - return [[], [pvModule.RenderProtoView]]; - }}); - Object.defineProperty(ViewFactory.prototype.getView, "parameters", {get: function() { - return [[pvModule.RenderProtoView]]; - }}); - Object.defineProperty(ViewFactory.prototype.returnView, "parameters", {get: function() { - return [[viewModule.RenderView]]; - }}); - Object.defineProperty(ViewFactory.prototype._createView, "parameters", {get: function() { - return [[pvModule.RenderProtoView], []]; - }}); - Object.defineProperty(ViewFactory.setComponentView, "parameters", {get: function() { - return [[ShadowDomStrategy], [viewModule.RenderView], [assert.type.number], [viewModule.RenderView]]; - }}); + }, {}, $__super); + }(Pipe)); + $__export("ObservablePipe", ObservablePipe); + ObservablePipeFactory = (function($__super) { + function $__1() { + $traceurRuntime.superConstructor($__1).call(this); + } + return ($traceurRuntime.createClass)($__1, { + supports: function(obs) { + return ObservableWrapper.isObservable(obs); + }, + create: function(cdRef) { + return new ObservablePipe(cdRef); + } + }, {}, $__super); + }(PipeFactory)); + $__export("ObservablePipeFactory", ObservablePipeFactory); + $__export("ObservablePipeFactory", ObservablePipeFactory = __decorate([CONST(), __metadata('design:paramtypes', [])], ObservablePipeFactory)); } }; }); -System.register("angular2/src/render/dom/compiler/compile_element", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/render/dom/view/proto_view_builder"], function($__export) { +System.register("angular2/src/di/binding", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/reflection/reflection", "angular2/src/di/key", "angular2/src/di/annotations_impl", "angular2/src/di/exceptions"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/compile_element"; - var assert, - List, - Map, - ListWrapper, - MapWrapper, - DOM, - int, + var __moduleName = "angular2/src/di/binding"; + var __decorate, + __metadata, + Type, isBlank, isPresent, - Type, - StringJoiner, - assertionsEnabled, - ProtoViewBuilder, - ElementBinderBuilder, - CompileElement; - function getElementDescription(domElement) { - var buf = new StringJoiner(); - var atts = DOM.attributeMap(domElement); - buf.add("<"); - buf.add(DOM.tagName(domElement).toLowerCase()); - addDescriptionAttribute(buf, "id", MapWrapper.get(atts, "id")); - addDescriptionAttribute(buf, "class", MapWrapper.get(atts, "class")); - MapWrapper.forEach(atts, (function(attValue, attName) { - if (attName !== "id" && attName !== "class") { - addDescriptionAttribute(buf, attName, attValue); - } + CONST, + ListWrapper, + reflector, + Key, + Inject, + InjectLazy, + InjectPromise, + Optional, + DependencyAnnotation, + NoAnnotationError, + Dependency, + _EMPTY_LIST, + Binding, + ResolvedBinding, + BindingBuilder; + function bind(token) { + return new BindingBuilder(token); + } + function _constructDependencies(factoryFunction, dependencies) { + return isBlank(dependencies) ? _dependenciesFor(factoryFunction) : ListWrapper.map(dependencies, (function(t) { + return Dependency.fromKey(Key.get(t)); })); - buf.add(">"); - return assert.returnType((buf.toString()), assert.type.string); } - function addDescriptionAttribute(buffer, attName, attValue) { - assert.argumentTypes(buffer, StringJoiner, attName, assert.type.string, attValue, assert.type.any); - if (isPresent(attValue)) { - if (attValue.length === 0) { - buffer.add(' ' + attName); - } else { - buffer.add(' ' + attName + '="' + attValue + '"'); + function _dependenciesFor(typeOrFunc) { + var params = reflector.parameters(typeOrFunc); + if (isBlank(params)) + return []; + if (ListWrapper.any(params, (function(p) { + return isBlank(p); + }))) { + throw new NoAnnotationError(typeOrFunc); + } + return ListWrapper.map(params, (function(p) { + return _extractToken(typeOrFunc, p); + })); + } + function _extractToken(typeOrFunc, annotations) { + var depProps = []; + var token = null; + var optional = false; + var lazy = false; + var asPromise = false; + for (var i = 0; i < annotations.length; ++i) { + var paramAnnotation = annotations[i]; + if (paramAnnotation instanceof Type) { + token = paramAnnotation; + } else if (paramAnnotation instanceof Inject) { + token = paramAnnotation.token; + } else if (paramAnnotation instanceof InjectPromise) { + token = paramAnnotation.token; + asPromise = true; + } else if (paramAnnotation instanceof InjectLazy) { + token = paramAnnotation.token; + lazy = true; + } else if (paramAnnotation instanceof Optional) { + optional = true; + } else if (paramAnnotation instanceof DependencyAnnotation) { + if (isPresent(paramAnnotation.token)) { + token = paramAnnotation.token; + } + ListWrapper.push(depProps, paramAnnotation); } } + if (isPresent(token)) { + return _createDependency(token, asPromise, lazy, optional, depProps); + } else { + throw new NoAnnotationError(typeOrFunc); + } + } + function _createDependency(token, asPromise, lazy, optional, depProps) { + return new Dependency(Key.get(token), asPromise, lazy, optional, depProps); } + $__export("bind", bind); return { setters: [function($__m) { - assert = $__m.assert; + Type = $__m.Type; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + CONST = $__m.CONST; }, function($__m) { - List = $__m.List; - Map = $__m.Map; ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; }, function($__m) { - DOM = $__m.DOM; + reflector = $__m.reflector; }, function($__m) { - int = $__m.int; - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - Type = $__m.Type; - StringJoiner = $__m.StringJoiner; - assertionsEnabled = $__m.assertionsEnabled; + Key = $__m.Key; }, function($__m) { - ProtoViewBuilder = $__m.ProtoViewBuilder; - ElementBinderBuilder = $__m.ElementBinderBuilder; + Inject = $__m.Inject; + InjectLazy = $__m.InjectLazy; + InjectPromise = $__m.InjectPromise; + Optional = $__m.Optional; + DependencyAnnotation = $__m.DependencyAnnotation; + }, function($__m) { + NoAnnotationError = $__m.NoAnnotationError; }], execute: function() { - CompileElement = (function() { - function CompileElement(element) { - var compilationUnit = arguments[1] !== (void 0) ? arguments[1] : ''; - this.element = element; - this._attrs = null; - this._classList = null; - this.isViewRoot = false; - this.inheritedProtoView = null; - this.inheritedElementBinder = null; - this.distanceToInheritedBinder = 0; - this.compileChildren = true; - var tplDesc = assertionsEnabled() ? getElementDescription(element) : null; - if (compilationUnit !== '') { - this.elementDescription = compilationUnit; - if (isPresent(tplDesc)) - this.elementDescription += ": " + tplDesc; + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + Dependency = (function() { + function Dependency(key, asPromise, lazy, optional, properties) { + this.key = key; + this.asPromise = asPromise; + this.lazy = lazy; + this.optional = optional; + this.properties = properties; + } + return ($traceurRuntime.createClass)(Dependency, {}, {fromKey: function(key) { + return new Dependency(key, false, false, false, []); + }}); + }()); + $__export("Dependency", Dependency); + _EMPTY_LIST = []; + Binding = (($traceurRuntime.createClass)(function(token, $__3) { + var $__4 = $__3, + toClass = $__4.toClass, + toValue = $__4.toValue, + toAlias = $__4.toAlias, + toFactory = $__4.toFactory, + toAsyncFactory = $__4.toAsyncFactory, + deps = $__4.deps; + this.token = token; + this.toClass = toClass; + this.toValue = toValue; + this.toAlias = toAlias; + this.toFactory = toFactory; + this.toAsyncFactory = toAsyncFactory; + this.dependencies = deps; + }, {resolve: function() { + var $__0 = this; + var factoryFn; + var resolvedDeps; + var isAsync = false; + if (isPresent(this.toClass)) { + factoryFn = reflector.factory(this.toClass); + resolvedDeps = _dependenciesFor(this.toClass); + } else if (isPresent(this.toAlias)) { + factoryFn = (function(aliasInstance) { + return aliasInstance; + }); + resolvedDeps = [Dependency.fromKey(Key.get(this.toAlias))]; + } else if (isPresent(this.toFactory)) { + factoryFn = this.toFactory; + resolvedDeps = _constructDependencies(this.toFactory, this.dependencies); + } else if (isPresent(this.toAsyncFactory)) { + factoryFn = this.toAsyncFactory; + resolvedDeps = _constructDependencies(this.toAsyncFactory, this.dependencies); + isAsync = true; } else { - this.elementDescription = tplDesc; + factoryFn = (function() { + return $__0.toValue; + }); + resolvedDeps = _EMPTY_LIST; } + return new ResolvedBinding(Key.get(this.token), factoryFn, resolvedDeps, isAsync); + }}, {})); + $__export("Binding", Binding); + $__export("Binding", Binding = __decorate([CONST(), __metadata('design:paramtypes', [Object, Object])], Binding)); + ResolvedBinding = (function() { + function ResolvedBinding(key, factory, dependencies, providedAsPromise) { + this.key = key; + this.factory = factory; + this.dependencies = dependencies; + this.providedAsPromise = providedAsPromise; + } + return ($traceurRuntime.createClass)(ResolvedBinding, {}, {}); + }()); + $__export("ResolvedBinding", ResolvedBinding); + BindingBuilder = (function() { + function BindingBuilder(token) { + this.token = token; } - return ($traceurRuntime.createClass)(CompileElement, { - isBound: function() { - return isPresent(this.inheritedElementBinder) && this.distanceToInheritedBinder === 0; - }, - bindElement: function() { - if (!this.isBound()) { - var parentBinder = this.inheritedElementBinder; - this.inheritedElementBinder = this.inheritedProtoView.bindElement(this.element, this.elementDescription); - if (isPresent(parentBinder)) { - this.inheritedElementBinder.setParent(parentBinder, this.distanceToInheritedBinder); - } - this.distanceToInheritedBinder = 0; - } - return this.inheritedElementBinder; + return ($traceurRuntime.createClass)(BindingBuilder, { + toClass: function(type) { + return new Binding(this.token, {toClass: type}); }, - refreshAttrs: function() { - this._attrs = null; + toValue: function(value) { + return new Binding(this.token, {toValue: value}); }, - attrs: function() { - if (isBlank(this._attrs)) { - this._attrs = DOM.attributeMap(this.element); - } - return assert.returnType((this._attrs), assert.genericType(Map, assert.type.string, assert.type.string)); + toAlias: function(aliasToken) { + return new Binding(this.token, {toAlias: aliasToken}); }, - refreshClassList: function() { - this._classList = null; + toFactory: function(factoryFunction, dependencies) { + return new Binding(this.token, { + toFactory: factoryFunction, + deps: dependencies + }); }, - classList: function() { - if (isBlank(this._classList)) { - this._classList = ListWrapper.create(); - var elClassList = DOM.classList(this.element); - for (var i = 0; i < elClassList.length; i++) { - ListWrapper.push(this._classList, elClassList[i]); - } - } - return assert.returnType((this._classList), assert.genericType(List, assert.type.string)); + toAsyncFactory: function(factoryFunction, dependencies) { + return new Binding(this.token, { + toAsyncFactory: factoryFunction, + deps: dependencies + }); } }, {}); }()); - $__export("CompileElement", CompileElement); - Object.defineProperty(addDescriptionAttribute, "parameters", {get: function() { - return [[StringJoiner], [assert.type.string], []]; - }}); + $__export("BindingBuilder", BindingBuilder); } }; }); -System.register("angular2/src/render/dom/compiler/compile_step_factory", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/facade/async", "angular2/change_detection", "angular2/src/render/api", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/property_binding_parser", "angular2/src/render/dom/compiler/text_interpolation_parser", "angular2/src/render/dom/compiler/directive_parser", "angular2/src/render/dom/compiler/view_splitter", "angular2/src/render/dom/shadow_dom/shadow_dom_compile_step", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { +System.register("angular2/src/render/dom/view/view", ["angular2/src/dom/dom_adapter", "angular2/src/facade/collection", "angular2/change_detection", "angular2/src/facade/lang", "angular2/src/render/dom/view/view_container", "angular2/src/render/dom/view/proto_view", "angular2/src/render/dom/shadow_dom/light_dom", "angular2/src/render/dom/shadow_dom/content_tag", "angular2/src/render/api"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/compile_step_factory"; - var assert, + var __moduleName = "angular2/src/render/dom/view/view"; + var DOM, + ListWrapper, + MapWrapper, + Map, + StringMapWrapper, List, - Promise, - Parser, - ViewDefinition, - CompileStep, - PropertyBindingParser, - TextInterpolationParser, - DirectiveParser, - ViewSplitter, - ShadowDomCompileStep, - ShadowDomStrategy, - CompileStepFactory, - DefaultStepFactory; + Locals, + int, + isPresent, + isBlank, + BaseException, + DomViewContainer, + DomProtoView, + LightDom, + Content, + RenderViewRef, + DomViewRef, + NG_BINDING_CLASS, + DomView; + function resolveInternalDomView(viewRef) { + var domViewRef = viewRef; + return domViewRef._view; + } + $__export("resolveInternalDomView", resolveInternalDomView); return { setters: [function($__m) { - assert = $__m.assert; + DOM = $__m.DOM; }, function($__m) { + ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; + Map = $__m.Map; + StringMapWrapper = $__m.StringMapWrapper; List = $__m.List; }, function($__m) { - Promise = $__m.Promise; - }, function($__m) { - Parser = $__m.Parser; - }, function($__m) { - ViewDefinition = $__m.ViewDefinition; - }, function($__m) { - CompileStep = $__m.CompileStep; + Locals = $__m.Locals; }, function($__m) { - PropertyBindingParser = $__m.PropertyBindingParser; + int = $__m.int; + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + BaseException = $__m.BaseException; }, function($__m) { - TextInterpolationParser = $__m.TextInterpolationParser; + DomViewContainer = $__m.DomViewContainer; }, function($__m) { - DirectiveParser = $__m.DirectiveParser; + DomProtoView = $__m.DomProtoView; }, function($__m) { - ViewSplitter = $__m.ViewSplitter; + LightDom = $__m.LightDom; }, function($__m) { - ShadowDomCompileStep = $__m.ShadowDomCompileStep; + Content = $__m.Content; }, function($__m) { - ShadowDomStrategy = $__m.ShadowDomStrategy; + RenderViewRef = $__m.RenderViewRef; }], execute: function() { - CompileStepFactory = (function() { - function CompileStepFactory() {} - return ($traceurRuntime.createClass)(CompileStepFactory, {createSteps: function(template, subTaskPromises) { - assert.argumentTypes(template, ViewDefinition, subTaskPromises, assert.genericType(List, Promise)); - return assert.returnType((null), assert.genericType(List, CompileStep)); - }}, {}); - }()); - $__export("CompileStepFactory", CompileStepFactory); - Object.defineProperty(CompileStepFactory.prototype.createSteps, "parameters", {get: function() { - return [[ViewDefinition], [assert.genericType(List, Promise)]]; + Object.defineProperty(resolveInternalDomView, "parameters", {get: function() { + return [[RenderViewRef]]; }}); - DefaultStepFactory = (function($__super) { - function DefaultStepFactory(parser, shadowDomStrategy) { - assert.argumentTypes(parser, Parser, shadowDomStrategy, assert.type.any); - $traceurRuntime.superConstructor(DefaultStepFactory).call(this); - this._parser = parser; - this._shadowDomStrategy = shadowDomStrategy; + DomViewRef = (function($__super) { + function DomViewRef(view) { + $traceurRuntime.superConstructor(DomViewRef).call(this); + this._view = view; } - return ($traceurRuntime.createClass)(DefaultStepFactory, {createSteps: function(template, subTaskPromises) { - assert.argumentTypes(template, ViewDefinition, subTaskPromises, assert.genericType(List, Promise)); - return [new ViewSplitter(this._parser), new PropertyBindingParser(this._parser), new DirectiveParser(this._parser, template.directives), new TextInterpolationParser(this._parser), new ShadowDomCompileStep(this._shadowDomStrategy, template, subTaskPromises)]; - }}, {}, $__super); - }(CompileStepFactory)); - $__export("DefaultStepFactory", DefaultStepFactory); - Object.defineProperty(DefaultStepFactory, "parameters", {get: function() { - return [[Parser], []]; + return ($traceurRuntime.createClass)(DomViewRef, {}, {}, $__super); + }(RenderViewRef)); + $__export("DomViewRef", DomViewRef); + Object.defineProperty(DomViewRef, "parameters", {get: function() { + return [[DomView]]; }}); - Object.defineProperty(DefaultStepFactory.prototype.createSteps, "parameters", {get: function() { - return [[ViewDefinition], [assert.genericType(List, Promise)]]; + NG_BINDING_CLASS = 'ng-binding'; + DomView = (function() { + function DomView(proto, rootNodes, boundTextNodes, boundElements, contentTags) { + this.proto = proto; + this.rootNodes = rootNodes; + this.boundTextNodes = boundTextNodes; + this.boundElements = boundElements; + this.viewContainers = ListWrapper.createFixedSize(boundElements.length); + this.contentTags = contentTags; + this.lightDoms = ListWrapper.createFixedSize(boundElements.length); + this.hostLightDom = null; + this.hydrated = false; + this.eventHandlerRemovers = []; + this.eventDispatcher = null; + this.shadowRoot = null; + } + return ($traceurRuntime.createClass)(DomView, { + getDirectParentLightDom: function(boundElementIndex) { + var binder = this.proto.elementBinders[boundElementIndex]; + var destLightDom = null; + if (binder.parentIndex !== -1 && binder.distanceToParent === 1) { + destLightDom = this.lightDoms[binder.parentIndex]; + } + return destLightDom; + }, + setElementProperty: function(elementIndex, propertyName, value) { + var setter = MapWrapper.get(this.proto.elementBinders[elementIndex].propertySetters, propertyName); + setter(this.boundElements[elementIndex], value); + }, + callAction: function(elementIndex, actionExpression, actionArgs) { + var binder = this.proto.elementBinders[elementIndex]; + var hostAction = MapWrapper.get(binder.hostActions, actionExpression); + hostAction.eval(this.boundElements[elementIndex], this._localsWithAction(actionArgs)); + }, + _localsWithAction: function(action) { + var map = MapWrapper.create(); + MapWrapper.set(map, '$action', action); + return new Locals(null, map); + }, + setText: function(textIndex, value) { + DOM.setText(this.boundTextNodes[textIndex], value); + }, + dispatchEvent: function(elementIndex, eventName, event) { + var allowDefaultBehavior = true; + if (isPresent(this.eventDispatcher)) { + var evalLocals = MapWrapper.create(); + MapWrapper.set(evalLocals, '$event', event); + allowDefaultBehavior = this.eventDispatcher.dispatchEvent(elementIndex, eventName, evalLocals); + if (!allowDefaultBehavior) { + event.preventDefault(); + } + } + return allowDefaultBehavior; + } + }, {}); + }()); + $__export("DomView", DomView); + Object.defineProperty(DomView, "parameters", {get: function() { + return [[DomProtoView], [List], [List], [List], [List]]; + }}); + Object.defineProperty(DomView.prototype.getDirectParentLightDom, "parameters", {get: function() { + return [[assert.type.number]]; + }}); + Object.defineProperty(DomView.prototype.setElementProperty, "parameters", {get: function() { + return [[assert.type.number], [assert.type.string], [assert.type.any]]; + }}); + Object.defineProperty(DomView.prototype.callAction, "parameters", {get: function() { + return [[assert.type.number], [assert.type.string], [assert.type.any]]; + }}); + Object.defineProperty(DomView.prototype._localsWithAction, "parameters", {get: function() { + return [[Object]]; + }}); + Object.defineProperty(DomView.prototype.setText, "parameters", {get: function() { + return [[assert.type.number], [assert.type.string]]; }}); } }; }); -System.register("angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy", ["rtts_assert/rtts_assert", "angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/light_dom", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/util"], function($__export) { +System.register("angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy", ["angular2/src/facade/async", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/view/view", "angular2/src/render/dom/shadow_dom/light_dom", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/util"], function($__export) { "use strict"; var __moduleName = "angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy"; - var assert, - Promise, + var Promise, DOM, viewModule, LightDom, ShadowDomStrategy, StyleUrlResolver, - moveViewNodesIntoParent, insertSharedStyleText, EmulatedUnscopedShadowDomStrategy; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Promise = $__m.Promise; }, function($__m) { DOM = $__m.DOM; @@ -25307,2619 +20671,2260 @@ System.register("angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom }, function($__m) { StyleUrlResolver = $__m.StyleUrlResolver; }, function($__m) { - moveViewNodesIntoParent = $__m.moveViewNodesIntoParent; insertSharedStyleText = $__m.insertSharedStyleText; }], execute: function() { EmulatedUnscopedShadowDomStrategy = (function($__super) { function EmulatedUnscopedShadowDomStrategy(styleUrlResolver, styleHost) { - assert.argumentTypes(styleUrlResolver, StyleUrlResolver, styleHost, assert.type.any); $traceurRuntime.superConstructor(EmulatedUnscopedShadowDomStrategy).call(this); this.styleUrlResolver = styleUrlResolver; this.styleHost = styleHost; } return ($traceurRuntime.createClass)(EmulatedUnscopedShadowDomStrategy, { hasNativeContentElement: function() { - return assert.returnType((false), assert.type.boolean); + return false; }, - attachTemplate: function(el, view) { - assert.argumentTypes(el, assert.type.any, view, viewModule.RenderView); - moveViewNodesIntoParent(el, view); + prepareShadowRoot: function(el) { + return el; }, - constructLightDom: function(lightDomView, shadowDomView, el) { - assert.argumentTypes(lightDomView, viewModule.RenderView, shadowDomView, viewModule.RenderView, el, assert.type.any); - return assert.returnType((new LightDom(lightDomView, shadowDomView, el)), LightDom); + constructLightDom: function(lightDomView, el) { + return new LightDom(lightDomView, el); }, processStyleElement: function(hostComponentId, templateUrl, styleEl) { - assert.argumentTypes(hostComponentId, assert.type.string, templateUrl, assert.type.string, styleEl, assert.type.any); var cssText = DOM.getText(styleEl); cssText = this.styleUrlResolver.resolveUrls(cssText, templateUrl); DOM.setText(styleEl, cssText); DOM.remove(styleEl); insertSharedStyleText(cssText, this.styleHost, styleEl); - return assert.returnType((null), Promise); + return null; } }, {}, $__super); }(ShadowDomStrategy)); $__export("EmulatedUnscopedShadowDomStrategy", EmulatedUnscopedShadowDomStrategy); Object.defineProperty(EmulatedUnscopedShadowDomStrategy, "parameters", {get: function() { return [[StyleUrlResolver], []]; - }}); - Object.defineProperty(EmulatedUnscopedShadowDomStrategy.prototype.attachTemplate, "parameters", {get: function() { - return [[], [viewModule.RenderView]]; - }}); - Object.defineProperty(EmulatedUnscopedShadowDomStrategy.prototype.constructLightDom, "parameters", {get: function() { - return [[viewModule.RenderView], [viewModule.RenderView], []]; - }}); - Object.defineProperty(EmulatedUnscopedShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string], []]; - }}); - } - }; -}); - -System.register("angular2/forms", ["angular2/src/forms/model", "angular2/src/forms/directives", "angular2/src/forms/validators", "angular2/src/forms/validator_directives", "angular2/src/forms/form_builder"], function($__export) { - "use strict"; - var __moduleName = "angular2/forms"; - var $__exportNames = {}; - var $__exportNames = {}; - var $__exportNames = {}; - var $__exportNames = {}; - var $__exportNames = {}; - return { - setters: [function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }, function($__m) { - Object.keys($__m).forEach(function(p) { - if (!$__exportNames[p]) - $__export(p, $__m[p]); - }); - }], - execute: function() {} - }; -}); - -System.register("angular2/src/di/binding", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/reflection/reflection", "angular2/src/di/key", "angular2/src/di/annotations", "angular2/src/di/exceptions"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/di/binding"; - var assert, - Type, - isBlank, - isPresent, - CONST, - List, - MapWrapper, - ListWrapper, - reflector, - Key, - Inject, - InjectLazy, - InjectPromise, - Optional, - DependencyAnnotation, - NoAnnotationError, - Dependency, - _EMPTY_LIST, - Binding, - ResolvedBinding, - BindingBuilder; - function bind(token) { - return assert.returnType((new BindingBuilder(token)), BindingBuilder); - } - function _constructDependencies(factoryFunction, dependencies) { - return isBlank(dependencies) ? _dependenciesFor(factoryFunction) : ListWrapper.map(dependencies, (function(t) { - return Dependency.fromKey(Key.get(t)); + }}); + Object.defineProperty(EmulatedUnscopedShadowDomStrategy.prototype.constructLightDom, "parameters", {get: function() { + return [[viewModule.DomView], []]; + }}); + Object.defineProperty(EmulatedUnscopedShadowDomStrategy.prototype.processStyleElement, "parameters", {get: function() { + return [[assert.type.string], [assert.type.string], []]; + }}); + } + }; +}); + +System.register("angular2/src/render/dom/compiler/compile_element", ["angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/render/dom/view/proto_view_builder"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/compiler/compile_element"; + var List, + Map, + ListWrapper, + MapWrapper, + DOM, + int, + isBlank, + isPresent, + Type, + StringJoiner, + assertionsEnabled, + ProtoViewBuilder, + ElementBinderBuilder, + CompileElement; + function getElementDescription(domElement) { + var buf = new StringJoiner(); + var atts = DOM.attributeMap(domElement); + buf.add("<"); + buf.add(DOM.tagName(domElement).toLowerCase()); + addDescriptionAttribute(buf, "id", MapWrapper.get(atts, "id")); + addDescriptionAttribute(buf, "class", MapWrapper.get(atts, "class")); + MapWrapper.forEach(atts, (function(attValue, attName) { + if (attName !== "id" && attName !== "class") { + addDescriptionAttribute(buf, attName, attValue); + } })); + buf.add(">"); + return buf.toString(); } - function _dependenciesFor(typeOrFunc) { - var params = reflector.parameters(typeOrFunc); - if (isBlank(params)) - return assert.returnType(([]), List); - if (ListWrapper.any(params, (function(p) { - return isBlank(p); - }))) - throw new NoAnnotationError(typeOrFunc); - return assert.returnType((ListWrapper.map(params, (function(p) { - return _extractToken(typeOrFunc, p); - }))), List); - } - function _extractToken(typeOrFunc, annotations) { - var depProps = []; - var token = null; - var optional = false; - var lazy = false; - var asPromise = false; - for (var i = 0; i < annotations.length; ++i) { - var paramAnnotation = annotations[i]; - if (paramAnnotation instanceof Type) { - token = paramAnnotation; - } else if (paramAnnotation instanceof Inject) { - token = paramAnnotation.token; - } else if (paramAnnotation instanceof InjectPromise) { - token = paramAnnotation.token; - asPromise = true; - } else if (paramAnnotation instanceof InjectLazy) { - token = paramAnnotation.token; - lazy = true; - } else if (paramAnnotation instanceof Optional) { - optional = true; - } else if (paramAnnotation instanceof DependencyAnnotation) { - if (isPresent(paramAnnotation.token)) { - token = paramAnnotation.token; - } - ListWrapper.push(depProps, paramAnnotation); + function addDescriptionAttribute(buffer, attName, attValue) { + if (isPresent(attValue)) { + if (attValue.length === 0) { + buffer.add(' ' + attName); + } else { + buffer.add(' ' + attName + '="' + attValue + '"'); } } - if (isPresent(token)) { - return _createDependency(token, asPromise, lazy, optional, depProps); - } else { - throw new NoAnnotationError(typeOrFunc); - } - } - function _createDependency(token, asPromise, lazy, optional, depProps) { - return assert.returnType((new Dependency(Key.get(token), asPromise, lazy, optional, depProps)), Dependency); } - $__export("bind", bind); return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Type = $__m.Type; - isBlank = $__m.isBlank; - isPresent = $__m.isPresent; - CONST = $__m.CONST; - }, function($__m) { List = $__m.List; - MapWrapper = $__m.MapWrapper; + Map = $__m.Map; ListWrapper = $__m.ListWrapper; + MapWrapper = $__m.MapWrapper; }, function($__m) { - reflector = $__m.reflector; - }, function($__m) { - Key = $__m.Key; + DOM = $__m.DOM; }, function($__m) { - Inject = $__m.Inject; - InjectLazy = $__m.InjectLazy; - InjectPromise = $__m.InjectPromise; - Optional = $__m.Optional; - DependencyAnnotation = $__m.DependencyAnnotation; + int = $__m.int; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + Type = $__m.Type; + StringJoiner = $__m.StringJoiner; + assertionsEnabled = $__m.assertionsEnabled; }, function($__m) { - NoAnnotationError = $__m.NoAnnotationError; + ProtoViewBuilder = $__m.ProtoViewBuilder; + ElementBinderBuilder = $__m.ElementBinderBuilder; }], execute: function() { - Dependency = (function() { - function Dependency(key, asPromise, lazy, optional, properties) { - assert.argumentTypes(key, Key, asPromise, assert.type.boolean, lazy, assert.type.boolean, optional, assert.type.boolean, properties, List); - this.key = key; - this.asPromise = asPromise; - this.lazy = lazy; - this.optional = optional; - this.properties = properties; + CompileElement = (function() { + function CompileElement(element) { + var compilationUnit = arguments[1] !== (void 0) ? arguments[1] : ''; + this.element = element; + this._attrs = null; + this._classList = null; + this.isViewRoot = false; + this.inheritedProtoView = null; + this.inheritedElementBinder = null; + this.distanceToInheritedBinder = 0; + this.compileChildren = true; + var tplDesc = assertionsEnabled() ? getElementDescription(element) : null; + if (compilationUnit !== '') { + this.elementDescription = compilationUnit; + if (isPresent(tplDesc)) + this.elementDescription += ": " + tplDesc; + } else { + this.elementDescription = tplDesc; + } } - return ($traceurRuntime.createClass)(Dependency, {}, {fromKey: function(key) { - assert.argumentTypes(key, Key); - return new Dependency(key, false, false, false, []); - }}); - }()); - $__export("Dependency", Dependency); - Object.defineProperty(Dependency, "parameters", {get: function() { - return [[Key], [assert.type.boolean], [assert.type.boolean], [assert.type.boolean], [List]]; - }}); - Object.defineProperty(Dependency.fromKey, "parameters", {get: function() { - return [[Key]]; - }}); - _EMPTY_LIST = []; - Binding = (function() { - function Binding(token, $__2) { - var $__3 = $__2, - toClass = $__3.toClass, - toValue = $__3.toValue, - toAlias = $__3.toAlias, - toFactory = $__3.toFactory, - toAsyncFactory = $__3.toAsyncFactory, - deps = $__3.deps; - this.token = token; - this.toClass = toClass; - this.toValue = toValue; - this.toAlias = toAlias; - this.toFactory = toFactory; - this.toAsyncFactory = toAsyncFactory; - this.dependencies = deps; - } - return ($traceurRuntime.createClass)(Binding, {resolve: function() { - var $__0 = this; - var factoryFn; - var resolvedDeps; - var isAsync = false; - if (isPresent(this.toClass)) { - factoryFn = reflector.factory(this.toClass); - resolvedDeps = _dependenciesFor(this.toClass); - } else if (isPresent(this.toAlias)) { - factoryFn = (function(aliasInstance) { - return aliasInstance; - }); - resolvedDeps = [Dependency.fromKey(Key.get(this.toAlias))]; - } else if (isPresent(this.toFactory)) { - factoryFn = this.toFactory; - resolvedDeps = _constructDependencies(this.toFactory, this.dependencies); - } else if (isPresent(this.toAsyncFactory)) { - factoryFn = this.toAsyncFactory; - resolvedDeps = _constructDependencies(this.toAsyncFactory, this.dependencies); - isAsync = true; - } else { - factoryFn = (function() { - return $__0.toValue; - }); - resolvedDeps = _EMPTY_LIST; + return ($traceurRuntime.createClass)(CompileElement, { + isBound: function() { + return isPresent(this.inheritedElementBinder) && this.distanceToInheritedBinder === 0; + }, + bindElement: function() { + if (!this.isBound()) { + var parentBinder = this.inheritedElementBinder; + this.inheritedElementBinder = this.inheritedProtoView.bindElement(this.element, this.elementDescription); + if (isPresent(parentBinder)) { + this.inheritedElementBinder.setParent(parentBinder, this.distanceToInheritedBinder); + } + this.distanceToInheritedBinder = 0; } - return assert.returnType((new ResolvedBinding(Key.get(this.token), factoryFn, resolvedDeps, isAsync)), ResolvedBinding); - }}, {}); - }()); - $__export("Binding", Binding); - Object.defineProperty(Binding, "annotations", {get: function() { - return [new CONST()]; - }}); - ResolvedBinding = (function() { - function ResolvedBinding(key, factory, dependencies, providedAsPromise) { - assert.argumentTypes(key, Key, factory, Function, dependencies, assert.genericType(List, Dependency), providedAsPromise, assert.type.boolean); - this.key = key; - this.factory = factory; - this.dependencies = dependencies; - this.providedAsPromise = providedAsPromise; - } - return ($traceurRuntime.createClass)(ResolvedBinding, {}, {}); - }()); - $__export("ResolvedBinding", ResolvedBinding); - Object.defineProperty(ResolvedBinding, "parameters", {get: function() { - return [[Key], [Function], [assert.genericType(List, Dependency)], [assert.type.boolean]]; - }}); - BindingBuilder = (function() { - function BindingBuilder(token) { - this.token = token; - } - return ($traceurRuntime.createClass)(BindingBuilder, { - toClass: function(type) { - assert.argumentTypes(type, Type); - return assert.returnType((new Binding(this.token, {toClass: type})), Binding); + return this.inheritedElementBinder; }, - toValue: function(value) { - return assert.returnType((new Binding(this.token, {toValue: value})), Binding); + refreshAttrs: function() { + this._attrs = null; }, - toAlias: function(aliasToken) { - return assert.returnType((new Binding(this.token, {toAlias: aliasToken})), Binding); + attrs: function() { + if (isBlank(this._attrs)) { + this._attrs = DOM.attributeMap(this.element); + } + return this._attrs; }, - toFactory: function(factoryFunction) { - var dependencies = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(factoryFunction, Function, dependencies, List); - return assert.returnType((new Binding(this.token, { - toFactory: factoryFunction, - deps: dependencies - })), Binding); + refreshClassList: function() { + this._classList = null; }, - toAsyncFactory: function(factoryFunction) { - var dependencies = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(factoryFunction, Function, dependencies, List); - return assert.returnType((new Binding(this.token, { - toAsyncFactory: factoryFunction, - deps: dependencies - })), Binding); + classList: function() { + if (isBlank(this._classList)) { + this._classList = ListWrapper.create(); + var elClassList = DOM.classList(this.element); + for (var i = 0; i < elClassList.length; i++) { + ListWrapper.push(this._classList, elClassList[i]); + } + } + return this._classList; } }, {}); }()); - $__export("BindingBuilder", BindingBuilder); - Object.defineProperty(BindingBuilder.prototype.toClass, "parameters", {get: function() { - return [[Type]]; - }}); - Object.defineProperty(BindingBuilder.prototype.toFactory, "parameters", {get: function() { - return [[Function], [List]]; + $__export("CompileElement", CompileElement); + Object.defineProperty(addDescriptionAttribute, "parameters", {get: function() { + return [[StringJoiner], [assert.type.string], []]; + }}); + } + }; +}); + +System.register("angular2/src/render/dom/compiler/compile_step_factory", ["angular2/src/facade/collection", "angular2/src/facade/async", "angular2/change_detection", "angular2/src/render/api", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/compiler/property_binding_parser", "angular2/src/render/dom/compiler/text_interpolation_parser", "angular2/src/render/dom/compiler/directive_parser", "angular2/src/render/dom/compiler/view_splitter", "angular2/src/render/dom/shadow_dom/shadow_dom_compile_step", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/compiler/compile_step_factory"; + var List, + Promise, + Parser, + ViewDefinition, + CompileStep, + PropertyBindingParser, + TextInterpolationParser, + DirectiveParser, + ViewSplitter, + ShadowDomCompileStep, + ShadowDomStrategy, + CompileStepFactory, + DefaultStepFactory; + return { + setters: [function($__m) { + List = $__m.List; + }, function($__m) { + Promise = $__m.Promise; + }, function($__m) { + Parser = $__m.Parser; + }, function($__m) { + ViewDefinition = $__m.ViewDefinition; + }, function($__m) { + CompileStep = $__m.CompileStep; + }, function($__m) { + PropertyBindingParser = $__m.PropertyBindingParser; + }, function($__m) { + TextInterpolationParser = $__m.TextInterpolationParser; + }, function($__m) { + DirectiveParser = $__m.DirectiveParser; + }, function($__m) { + ViewSplitter = $__m.ViewSplitter; + }, function($__m) { + ShadowDomCompileStep = $__m.ShadowDomCompileStep; + }, function($__m) { + ShadowDomStrategy = $__m.ShadowDomStrategy; + }], + execute: function() { + CompileStepFactory = (function() { + function CompileStepFactory() {} + return ($traceurRuntime.createClass)(CompileStepFactory, {createSteps: function(template, subTaskPromises) { + return null; + }}, {}); + }()); + $__export("CompileStepFactory", CompileStepFactory); + Object.defineProperty(CompileStepFactory.prototype.createSteps, "parameters", {get: function() { + return [[ViewDefinition], [assert.genericType(List, Promise)]]; }}); - Object.defineProperty(BindingBuilder.prototype.toAsyncFactory, "parameters", {get: function() { - return [[Function], [List]]; + DefaultStepFactory = (function($__super) { + function DefaultStepFactory(parser, shadowDomStrategy) { + $traceurRuntime.superConstructor(DefaultStepFactory).call(this); + this._parser = parser; + this._shadowDomStrategy = shadowDomStrategy; + } + return ($traceurRuntime.createClass)(DefaultStepFactory, {createSteps: function(template, subTaskPromises) { + return [new ViewSplitter(this._parser), new PropertyBindingParser(this._parser), new DirectiveParser(this._parser, template.directives), new TextInterpolationParser(this._parser), new ShadowDomCompileStep(this._shadowDomStrategy, template, subTaskPromises)]; + }}, {}, $__super); + }(CompileStepFactory)); + $__export("DefaultStepFactory", DefaultStepFactory); + Object.defineProperty(DefaultStepFactory, "parameters", {get: function() { + return [[Parser], []]; }}); - Object.defineProperty(_constructDependencies, "parameters", {get: function() { - return [[Function], [List]]; + Object.defineProperty(DefaultStepFactory.prototype.createSteps, "parameters", {get: function() { + return [[ViewDefinition], [assert.genericType(List, Promise)]]; }}); } }; }); -System.register("angular2/src/change_detection/proto_record", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/change_detection/binding_record", "angular2/src/change_detection/directive_record"], function($__export) { +System.register("angular2/forms", ["angular2/src/forms/model", "angular2/src/forms/directives", "angular2/src/forms/validators", "angular2/src/forms/validator_directives", "angular2/src/forms/form_builder"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/proto_record"; - var assert, - List, - BindingRecord, - DirectiveIndex, - RECORD_TYPE_SELF, - RECORD_TYPE_CONST, - RECORD_TYPE_PRIMITIVE_OP, - RECORD_TYPE_PROPERTY, - RECORD_TYPE_LOCAL, - RECORD_TYPE_INVOKE_METHOD, - RECORD_TYPE_INVOKE_CLOSURE, - RECORD_TYPE_KEYED_ACCESS, - RECORD_TYPE_PIPE, - RECORD_TYPE_BINDING_PIPE, - RECORD_TYPE_INTERPOLATE, - ProtoRecord; + var __moduleName = "angular2/forms"; + var $__exportNames = {}; + var $__exportNames = {}; + var $__exportNames = {}; + var $__exportNames = {}; + var $__exportNames = {}; return { setters: [function($__m) { - assert = $__m.assert; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); }, function($__m) { - List = $__m.List; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); }, function($__m) { - BindingRecord = $__m.BindingRecord; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); }, function($__m) { - DirectiveIndex = $__m.DirectiveIndex; + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); }], - execute: function() { - RECORD_TYPE_SELF = 0; - $__export("RECORD_TYPE_SELF", RECORD_TYPE_SELF); - RECORD_TYPE_CONST = 1; - $__export("RECORD_TYPE_CONST", RECORD_TYPE_CONST); - RECORD_TYPE_PRIMITIVE_OP = 2; - $__export("RECORD_TYPE_PRIMITIVE_OP", RECORD_TYPE_PRIMITIVE_OP); - RECORD_TYPE_PROPERTY = 3; - $__export("RECORD_TYPE_PROPERTY", RECORD_TYPE_PROPERTY); - RECORD_TYPE_LOCAL = 4; - $__export("RECORD_TYPE_LOCAL", RECORD_TYPE_LOCAL); - RECORD_TYPE_INVOKE_METHOD = 5; - $__export("RECORD_TYPE_INVOKE_METHOD", RECORD_TYPE_INVOKE_METHOD); - RECORD_TYPE_INVOKE_CLOSURE = 6; - $__export("RECORD_TYPE_INVOKE_CLOSURE", RECORD_TYPE_INVOKE_CLOSURE); - RECORD_TYPE_KEYED_ACCESS = 7; - $__export("RECORD_TYPE_KEYED_ACCESS", RECORD_TYPE_KEYED_ACCESS); - RECORD_TYPE_PIPE = 8; - $__export("RECORD_TYPE_PIPE", RECORD_TYPE_PIPE); - RECORD_TYPE_BINDING_PIPE = 9; - $__export("RECORD_TYPE_BINDING_PIPE", RECORD_TYPE_BINDING_PIPE); - RECORD_TYPE_INTERPOLATE = 10; - $__export("RECORD_TYPE_INTERPOLATE", RECORD_TYPE_INTERPOLATE); - ProtoRecord = (function() { - function ProtoRecord(mode, name, funcOrValue, args, fixedArgs, contextIndex, directiveIndex, selfIndex, bindingRecord, expressionAsString, lastInBinding, lastInDirective) { - assert.argumentTypes(mode, assert.type.number, name, assert.type.string, funcOrValue, assert.type.any, args, List, fixedArgs, List, contextIndex, assert.type.number, directiveIndex, DirectiveIndex, selfIndex, assert.type.number, bindingRecord, BindingRecord, expressionAsString, assert.type.string, lastInBinding, assert.type.boolean, lastInDirective, assert.type.boolean); - this.mode = mode; - this.name = name; - this.funcOrValue = funcOrValue; - this.args = args; - this.fixedArgs = fixedArgs; - this.contextIndex = contextIndex; - this.directiveIndex = directiveIndex; - this.selfIndex = selfIndex; - this.bindingRecord = bindingRecord; - this.lastInBinding = lastInBinding; - this.lastInDirective = lastInDirective; - this.expressionAsString = expressionAsString; - } - return ($traceurRuntime.createClass)(ProtoRecord, {isPureFunction: function() { - return assert.returnType((this.mode === RECORD_TYPE_INTERPOLATE || this.mode === RECORD_TYPE_PRIMITIVE_OP), assert.type.boolean); - }}, {}); - }()); - $__export("ProtoRecord", ProtoRecord); - Object.defineProperty(ProtoRecord, "parameters", {get: function() { - return [[assert.type.number], [assert.type.string], [], [List], [List], [assert.type.number], [DirectiveIndex], [assert.type.number], [BindingRecord], [assert.type.string], [assert.type.boolean], [assert.type.boolean]]; - }}); - } + execute: function() {} }; }); -System.register("angular2/src/change_detection/proto_change_detector", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/parser/ast", "angular2/src/change_detection/interfaces", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/dynamic_change_detector", "angular2/src/change_detection/change_detection_jit_generator", "angular2/src/change_detection/pipes/pipe_registry", "angular2/src/change_detection/binding_record", "angular2/src/change_detection/directive_record", "angular2/src/change_detection/coalesce", "angular2/src/change_detection/proto_record"], function($__export) { +System.register("angular2/src/change_detection/parser/lexer", ["angular2/src/di/decorators", "angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/proto_change_detector"; - var assert, - isPresent, - isBlank, - BaseException, - Type, - isString, - List, + var __moduleName = "angular2/src/change_detection/parser/lexer"; + var __decorate, + __metadata, + Injectable, ListWrapper, - MapWrapper, - StringMapWrapper, - AccessMember, - Assignment, - AST, - ASTWithSource, - AstVisitor, - Binary, - Chain, - Conditional, - Pipe, - FunctionCall, - ImplicitReceiver, - Interpolation, - KeyedAccess, - LiteralArray, - LiteralMap, - LiteralPrimitive, - MethodCall, - PrefixNot, - ChangeDispatcher, - ChangeDetector, - ProtoChangeDetector, - ChangeDetectionUtil, - DynamicChangeDetector, - ChangeDetectorJITGenerator, - PipeRegistry, - BindingRecord, - DirectiveIndex, - coalesce, - ProtoRecord, - RECORD_TYPE_SELF, - RECORD_TYPE_PROPERTY, - RECORD_TYPE_LOCAL, - RECORD_TYPE_INVOKE_METHOD, - RECORD_TYPE_CONST, - RECORD_TYPE_INVOKE_CLOSURE, - RECORD_TYPE_PRIMITIVE_OP, - RECORD_TYPE_KEYED_ACCESS, - RECORD_TYPE_PIPE, - RECORD_TYPE_BINDING_PIPE, - RECORD_TYPE_INTERPOLATE, - DynamicProtoChangeDetector, - _jitProtoChangeDetectorClassCounter, - JitProtoChangeDetector, - ProtoRecordBuilder, - _ConvertAstIntoProtoRecords; - function _arrayFn(length) { - assert.argumentTypes(length, assert.type.number); - switch (length) { - case 0: - return assert.returnType((ChangeDetectionUtil.arrayFn0), Function); - case 1: - return assert.returnType((ChangeDetectionUtil.arrayFn1), Function); - case 2: - return assert.returnType((ChangeDetectionUtil.arrayFn2), Function); - case 3: - return assert.returnType((ChangeDetectionUtil.arrayFn3), Function); - case 4: - return assert.returnType((ChangeDetectionUtil.arrayFn4), Function); - case 5: - return assert.returnType((ChangeDetectionUtil.arrayFn5), Function); - case 6: - return assert.returnType((ChangeDetectionUtil.arrayFn6), Function); - case 7: - return assert.returnType((ChangeDetectionUtil.arrayFn7), Function); - case 8: - return assert.returnType((ChangeDetectionUtil.arrayFn8), Function); - case 9: - return assert.returnType((ChangeDetectionUtil.arrayFn9), Function); - default: - throw new BaseException("Does not support literal maps with more than 9 elements"); - } + SetWrapper, + NumberWrapper, + StringJoiner, + StringWrapper, + BaseException, + __esModule, + TOKEN_TYPE_CHARACTER, + TOKEN_TYPE_IDENTIFIER, + TOKEN_TYPE_KEYWORD, + TOKEN_TYPE_STRING, + TOKEN_TYPE_OPERATOR, + TOKEN_TYPE_NUMBER, + Lexer, + Token, + EOF, + $EOF, + $TAB, + $LF, + $VTAB, + $FF, + $CR, + $SPACE, + $BANG, + $DQ, + $HASH, + $$, + $PERCENT, + $AMPERSAND, + $SQ, + $LPAREN, + $RPAREN, + $STAR, + $PLUS, + $COMMA, + $MINUS, + $PERIOD, + $SLASH, + $COLON, + $SEMICOLON, + $LT, + $EQ, + $GT, + $QUESTION, + $0, + $9, + $A, + $E, + $Z, + $LBRACKET, + $BACKSLASH, + $RBRACKET, + $CARET, + $_, + $a, + $e, + $f, + $n, + $r, + $t, + $u, + $v, + $z, + $LBRACE, + $BAR, + $RBRACE, + $NBSP, + ScannerError, + _Scanner, + OPERATORS, + KEYWORDS; + function newCharacterToken(index, code) { + return new Token(index, TOKEN_TYPE_CHARACTER, code, StringWrapper.fromCharCode(code)); } - function _mapPrimitiveName(keys) { - var stringifiedKeys = ListWrapper.join(ListWrapper.map(keys, (function(k) { - return isString(k) ? ("\"" + k + "\"") : ("" + k); - })), ", "); - return ("mapFn([" + stringifiedKeys + "])"); + function newIdentifierToken(index, text) { + return new Token(index, TOKEN_TYPE_IDENTIFIER, 0, text); } - function _operationToPrimitiveName(operation) { - assert.argumentTypes(operation, assert.type.string); - switch (operation) { - case '+': - return assert.returnType(("operation_add"), assert.type.string); - case '-': - return assert.returnType(("operation_subtract"), assert.type.string); - case '*': - return assert.returnType(("operation_multiply"), assert.type.string); - case '/': - return assert.returnType(("operation_divide"), assert.type.string); - case '%': - return assert.returnType(("operation_remainder"), assert.type.string); - case '==': - return assert.returnType(("operation_equals"), assert.type.string); - case '!=': - return assert.returnType(("operation_not_equals"), assert.type.string); - case '<': - return assert.returnType(("operation_less_then"), assert.type.string); - case '>': - return assert.returnType(("operation_greater_then"), assert.type.string); - case '<=': - return assert.returnType(("operation_less_or_equals_then"), assert.type.string); - case '>=': - return assert.returnType(("operation_greater_or_equals_then"), assert.type.string); - case '&&': - return assert.returnType(("operation_logical_and"), assert.type.string); - case '||': - return assert.returnType(("operation_logical_or"), assert.type.string); - default: - throw new BaseException(("Unsupported operation " + operation)); - } + function newKeywordToken(index, text) { + return new Token(index, TOKEN_TYPE_KEYWORD, 0, text); } - function _operationToFunction(operation) { - assert.argumentTypes(operation, assert.type.string); - switch (operation) { - case '+': - return assert.returnType((ChangeDetectionUtil.operation_add), Function); - case '-': - return assert.returnType((ChangeDetectionUtil.operation_subtract), Function); - case '*': - return assert.returnType((ChangeDetectionUtil.operation_multiply), Function); - case '/': - return assert.returnType((ChangeDetectionUtil.operation_divide), Function); - case '%': - return assert.returnType((ChangeDetectionUtil.operation_remainder), Function); - case '==': - return assert.returnType((ChangeDetectionUtil.operation_equals), Function); - case '!=': - return assert.returnType((ChangeDetectionUtil.operation_not_equals), Function); - case '<': - return assert.returnType((ChangeDetectionUtil.operation_less_then), Function); - case '>': - return assert.returnType((ChangeDetectionUtil.operation_greater_then), Function); - case '<=': - return assert.returnType((ChangeDetectionUtil.operation_less_or_equals_then), Function); - case '>=': - return assert.returnType((ChangeDetectionUtil.operation_greater_or_equals_then), Function); - case '&&': - return assert.returnType((ChangeDetectionUtil.operation_logical_and), Function); - case '||': - return assert.returnType((ChangeDetectionUtil.operation_logical_or), Function); - default: - throw new BaseException(("Unsupported operation " + operation)); - } + function newOperatorToken(index, text) { + return new Token(index, TOKEN_TYPE_OPERATOR, 0, text); } - function s(v) { - return isPresent(v) ? ("" + v) : ''; + function newStringToken(index, text) { + return new Token(index, TOKEN_TYPE_STRING, 0, text); } - function _interpolationFn(strings) { - var length = strings.length; - var c0 = length > 0 ? strings[0] : null; - var c1 = length > 1 ? strings[1] : null; - var c2 = length > 2 ? strings[2] : null; - var c3 = length > 3 ? strings[3] : null; - var c4 = length > 4 ? strings[4] : null; - var c5 = length > 5 ? strings[5] : null; - var c6 = length > 6 ? strings[6] : null; - var c7 = length > 7 ? strings[7] : null; - var c8 = length > 8 ? strings[8] : null; - var c9 = length > 9 ? strings[9] : null; - switch (length - 1) { - case 1: - return (function(a1) { - return c0 + s(a1) + c1; - }); - case 2: - return (function(a1, a2) { - return c0 + s(a1) + c1 + s(a2) + c2; - }); - case 3: - return (function(a1, a2, a3) { - return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3; - }); - case 4: - return (function(a1, a2, a3, a4) { - return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4; - }); - case 5: - return (function(a1, a2, a3, a4, a5) { - return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5; - }); - case 6: - return (function(a1, a2, a3, a4, a5, a6) { - return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6; - }); - case 7: - return (function(a1, a2, a3, a4, a5, a6, a7) { - return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6 + s(a7) + c7; - }); - case 8: - return (function(a1, a2, a3, a4, a5, a6, a7, a8) { - return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6 + s(a7) + c7 + s(a8) + c8; - }); - case 9: - return (function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { - return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6 + s(a7) + c7 + s(a8) + c8 + s(a9) + c9; - }); + function newNumberToken(index, n) { + return new Token(index, TOKEN_TYPE_NUMBER, n, ""); + } + function isWhitespace(code) { + return (code >= $TAB && code <= $SPACE) || (code == $NBSP); + } + function isIdentifierStart(code) { + return ($a <= code && code <= $z) || ($A <= code && code <= $Z) || (code == $_) || (code == $$); + } + function isIdentifierPart(code) { + return ($a <= code && code <= $z) || ($A <= code && code <= $Z) || ($0 <= code && code <= $9) || (code == $_) || (code == $$); + } + function isDigit(code) { + return $0 <= code && code <= $9; + } + function isExponentStart(code) { + return code == $e || code == $E; + } + function isExponentSign(code) { + return code == $MINUS || code == $PLUS; + } + function unescape(code) { + switch (code) { + case $n: + return $LF; + case $f: + return $FF; + case $r: + return $CR; + case $t: + return $TAB; + case $v: + return $VTAB; default: - throw new BaseException("Does not support more than 9 expressions"); + return code; } } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; - BaseException = $__m.BaseException; - Type = $__m.Type; - isString = $__m.isString; + Injectable = $__m.Injectable; }, function($__m) { - List = $__m.List; ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - StringMapWrapper = $__m.StringMapWrapper; - }, function($__m) { - AccessMember = $__m.AccessMember; - Assignment = $__m.Assignment; - AST = $__m.AST; - ASTWithSource = $__m.ASTWithSource; - AstVisitor = $__m.AstVisitor; - Binary = $__m.Binary; - Chain = $__m.Chain; - Conditional = $__m.Conditional; - Pipe = $__m.Pipe; - FunctionCall = $__m.FunctionCall; - ImplicitReceiver = $__m.ImplicitReceiver; - Interpolation = $__m.Interpolation; - KeyedAccess = $__m.KeyedAccess; - LiteralArray = $__m.LiteralArray; - LiteralMap = $__m.LiteralMap; - LiteralPrimitive = $__m.LiteralPrimitive; - MethodCall = $__m.MethodCall; - PrefixNot = $__m.PrefixNot; - }, function($__m) { - ChangeDispatcher = $__m.ChangeDispatcher; - ChangeDetector = $__m.ChangeDetector; - ProtoChangeDetector = $__m.ProtoChangeDetector; - }, function($__m) { - ChangeDetectionUtil = $__m.ChangeDetectionUtil; - }, function($__m) { - DynamicChangeDetector = $__m.DynamicChangeDetector; - }, function($__m) { - ChangeDetectorJITGenerator = $__m.ChangeDetectorJITGenerator; - }, function($__m) { - PipeRegistry = $__m.PipeRegistry; - }, function($__m) { - BindingRecord = $__m.BindingRecord; - }, function($__m) { - DirectiveIndex = $__m.DirectiveIndex; - }, function($__m) { - coalesce = $__m.coalesce; + SetWrapper = $__m.SetWrapper; }, function($__m) { - ProtoRecord = $__m.ProtoRecord; - RECORD_TYPE_SELF = $__m.RECORD_TYPE_SELF; - RECORD_TYPE_PROPERTY = $__m.RECORD_TYPE_PROPERTY; - RECORD_TYPE_LOCAL = $__m.RECORD_TYPE_LOCAL; - RECORD_TYPE_INVOKE_METHOD = $__m.RECORD_TYPE_INVOKE_METHOD; - RECORD_TYPE_CONST = $__m.RECORD_TYPE_CONST; - RECORD_TYPE_INVOKE_CLOSURE = $__m.RECORD_TYPE_INVOKE_CLOSURE; - RECORD_TYPE_PRIMITIVE_OP = $__m.RECORD_TYPE_PRIMITIVE_OP; - RECORD_TYPE_KEYED_ACCESS = $__m.RECORD_TYPE_KEYED_ACCESS; - RECORD_TYPE_PIPE = $__m.RECORD_TYPE_PIPE; - RECORD_TYPE_BINDING_PIPE = $__m.RECORD_TYPE_BINDING_PIPE; - RECORD_TYPE_INTERPOLATE = $__m.RECORD_TYPE_INTERPOLATE; + NumberWrapper = $__m.NumberWrapper; + StringJoiner = $__m.StringJoiner; + StringWrapper = $__m.StringWrapper; + BaseException = $__m.BaseException; }], execute: function() { - DynamicProtoChangeDetector = (function($__super) { - function DynamicProtoChangeDetector(pipeRegistry, changeControlStrategy) { - assert.argumentTypes(pipeRegistry, PipeRegistry, changeControlStrategy, assert.type.string); - $traceurRuntime.superConstructor(DynamicProtoChangeDetector).call(this); - this._pipeRegistry = pipeRegistry; - this._changeControlStrategy = changeControlStrategy; - } - return ($traceurRuntime.createClass)(DynamicProtoChangeDetector, { - instantiate: function(dispatcher, bindingRecords, variableBindings, directiveRecords) { - assert.argumentTypes(dispatcher, assert.type.any, bindingRecords, List, variableBindings, List, directiveRecords, List); - this._createRecordsIfNecessary(bindingRecords, variableBindings); - return new DynamicChangeDetector(this._changeControlStrategy, dispatcher, this._pipeRegistry, this._records, directiveRecords); - }, - _createRecordsIfNecessary: function(bindingRecords, variableBindings) { - assert.argumentTypes(bindingRecords, List, variableBindings, List); - if (isBlank(this._records)) { - var recordBuilder = new ProtoRecordBuilder(); - ListWrapper.forEach(bindingRecords, (function(b) { - recordBuilder.addAst(b, variableBindings); - })); - this._records = coalesce(recordBuilder.records); - } - } - }, {}, $__super); - }(ProtoChangeDetector)); - $__export("DynamicProtoChangeDetector", DynamicProtoChangeDetector); - Object.defineProperty(DynamicProtoChangeDetector, "parameters", {get: function() { - return [[PipeRegistry], [assert.type.string]]; - }}); - Object.defineProperty(DynamicProtoChangeDetector.prototype.instantiate, "parameters", {get: function() { - return [[assert.type.any], [List], [List], [List]]; - }}); - Object.defineProperty(DynamicProtoChangeDetector.prototype._createRecordsIfNecessary, "parameters", {get: function() { - return [[List], [List]]; - }}); - _jitProtoChangeDetectorClassCounter = assert.type(0, assert.type.number); - JitProtoChangeDetector = (function($__super) { - function JitProtoChangeDetector(pipeRegistry, changeControlStrategy) { - assert.argumentTypes(pipeRegistry, assert.type.any, changeControlStrategy, assert.type.string); - $traceurRuntime.superConstructor(JitProtoChangeDetector).call(this); - this._pipeRegistry = pipeRegistry; - this._factory = null; - this._changeControlStrategy = changeControlStrategy; - } - return ($traceurRuntime.createClass)(JitProtoChangeDetector, { - instantiate: function(dispatcher, bindingRecords, variableBindings, directiveRecords) { - assert.argumentTypes(dispatcher, assert.type.any, bindingRecords, List, variableBindings, List, directiveRecords, List); - this._createFactoryIfNecessary(bindingRecords, variableBindings, directiveRecords); - return this._factory(dispatcher, this._pipeRegistry); - }, - _createFactoryIfNecessary: function(bindingRecords, variableBindings, directiveRecords) { - assert.argumentTypes(bindingRecords, List, variableBindings, List, directiveRecords, List); - if (isBlank(this._factory)) { - var recordBuilder = new ProtoRecordBuilder(); - ListWrapper.forEach(bindingRecords, (function(b) { - recordBuilder.addAst(b, variableBindings); - })); - var c = _jitProtoChangeDetectorClassCounter++; - var records = coalesce(recordBuilder.records); - var typeName = ("ChangeDetector" + c); - this._factory = new ChangeDetectorJITGenerator(typeName, this._changeControlStrategy, records, directiveRecords).generate(); - } - } - }, {}, $__super); - }(ProtoChangeDetector)); - $__export("JitProtoChangeDetector", JitProtoChangeDetector); - Object.defineProperty(JitProtoChangeDetector, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(JitProtoChangeDetector.prototype.instantiate, "parameters", {get: function() { - return [[assert.type.any], [List], [List], [List]]; - }}); - Object.defineProperty(JitProtoChangeDetector.prototype._createFactoryIfNecessary, "parameters", {get: function() { - return [[List], [List], [List]]; - }}); - ProtoRecordBuilder = (function() { - function ProtoRecordBuilder() { - this.records = []; + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); } - return ($traceurRuntime.createClass)(ProtoRecordBuilder, {addAst: function(b) { - var variableBindings = arguments[1] !== (void 0) ? arguments[1] : null; - assert.argumentTypes(b, BindingRecord, variableBindings, List); - var last = ListWrapper.last(this.records); - if (isPresent(last) && last.bindingRecord.directiveRecord == b.directiveRecord) { - last.lastInDirective = false; - } - var pr = _ConvertAstIntoProtoRecords.convert(b, this.records.length, variableBindings); - if (!ListWrapper.isEmpty(pr)) { - var last = ListWrapper.last(pr); - last.lastInBinding = true; - last.lastInDirective = true; - this.records = ListWrapper.concat(this.records, pr); - } - }}, {}); - }()); - Object.defineProperty(ProtoRecordBuilder.prototype.addAst, "parameters", {get: function() { - return [[BindingRecord], [List]]; - }}); - _ConvertAstIntoProtoRecords = (function() { - function _ConvertAstIntoProtoRecords(bindingRecord, contextIndex, expressionAsString, variableBindings) { - assert.argumentTypes(bindingRecord, BindingRecord, contextIndex, assert.type.number, expressionAsString, assert.type.string, variableBindings, List); - this.protoRecords = []; - this.bindingRecord = bindingRecord; - this.contextIndex = contextIndex; - this.expressionAsString = expressionAsString; - this.variableBindings = variableBindings; + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + TOKEN_TYPE_CHARACTER = 1; + $__export("TOKEN_TYPE_CHARACTER", TOKEN_TYPE_CHARACTER); + TOKEN_TYPE_IDENTIFIER = 2; + $__export("TOKEN_TYPE_IDENTIFIER", TOKEN_TYPE_IDENTIFIER); + TOKEN_TYPE_KEYWORD = 3; + $__export("TOKEN_TYPE_KEYWORD", TOKEN_TYPE_KEYWORD); + TOKEN_TYPE_STRING = 4; + $__export("TOKEN_TYPE_STRING", TOKEN_TYPE_STRING); + TOKEN_TYPE_OPERATOR = 5; + $__export("TOKEN_TYPE_OPERATOR", TOKEN_TYPE_OPERATOR); + TOKEN_TYPE_NUMBER = 6; + $__export("TOKEN_TYPE_NUMBER", TOKEN_TYPE_NUMBER); + Lexer = (($traceurRuntime.createClass)(function() {}, {tokenize: function(text) { + var scanner = new _Scanner(text); + var tokens = []; + var token = scanner.scanToken(); + while (token != null) { + ListWrapper.push(tokens, token); + token = scanner.scanToken(); + } + return tokens; + }}, {})); + $__export("Lexer", Lexer); + $__export("Lexer", Lexer = __decorate([Injectable(), __metadata('design:paramtypes', [])], Lexer)); + Token = (function() { + function Token(index, type, numValue, strValue) { + this.index = index; + this.type = type; + this.numValue = numValue; + this.strValue = strValue; } - return ($traceurRuntime.createClass)(_ConvertAstIntoProtoRecords, { - visitImplicitReceiver: function(ast) { - assert.argumentTypes(ast, ImplicitReceiver); - return this.bindingRecord.implicitReceiver; + return ($traceurRuntime.createClass)(Token, { + isCharacter: function(code) { + return (this.type == TOKEN_TYPE_CHARACTER && this.numValue == code); }, - visitInterpolation: function(ast) { - assert.argumentTypes(ast, Interpolation); - var args = this._visitAll(ast.expressions); - return this._addRecord(RECORD_TYPE_INTERPOLATE, "interpolate", _interpolationFn(ast.strings), args, ast.strings, 0); + isNumber: function() { + return (this.type == TOKEN_TYPE_NUMBER); }, - visitLiteralPrimitive: function(ast) { - assert.argumentTypes(ast, LiteralPrimitive); - return this._addRecord(RECORD_TYPE_CONST, "literal", ast.value, [], null, 0); + isString: function() { + return (this.type == TOKEN_TYPE_STRING); }, - visitAccessMember: function(ast) { - assert.argumentTypes(ast, AccessMember); - var receiver = ast.receiver.visit(this); - if (isPresent(this.variableBindings) && ListWrapper.contains(this.variableBindings, ast.name) && ast.receiver instanceof ImplicitReceiver) { - return this._addRecord(RECORD_TYPE_LOCAL, ast.name, ast.name, [], null, receiver); - } else { - return this._addRecord(RECORD_TYPE_PROPERTY, ast.name, ast.getter, [], null, receiver); - } + isOperator: function(operater) { + return (this.type == TOKEN_TYPE_OPERATOR && this.strValue == operater); }, - visitMethodCall: function(ast) { - assert.argumentTypes(ast, MethodCall); - ; - var receiver = ast.receiver.visit(this); - var args = this._visitAll(ast.args); - if (isPresent(this.variableBindings) && ListWrapper.contains(this.variableBindings, ast.name)) { - var target = this._addRecord(RECORD_TYPE_LOCAL, ast.name, ast.name, [], null, receiver); - return this._addRecord(RECORD_TYPE_INVOKE_CLOSURE, "closure", null, args, null, target); - } else { - return this._addRecord(RECORD_TYPE_INVOKE_METHOD, ast.name, ast.fn, args, null, receiver); - } + isIdentifier: function() { + return (this.type == TOKEN_TYPE_IDENTIFIER); }, - visitFunctionCall: function(ast) { - assert.argumentTypes(ast, FunctionCall); - var target = ast.target.visit(this); - var args = this._visitAll(ast.args); - return this._addRecord(RECORD_TYPE_INVOKE_CLOSURE, "closure", null, args, null, target); + isKeyword: function() { + return (this.type == TOKEN_TYPE_KEYWORD); }, - visitLiteralArray: function(ast) { - assert.argumentTypes(ast, LiteralArray); - var primitiveName = ("arrayFn" + ast.expressions.length); - return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, primitiveName, _arrayFn(ast.expressions.length), this._visitAll(ast.expressions), null, 0); + isKeywordVar: function() { + return (this.type == TOKEN_TYPE_KEYWORD && this.strValue == "var"); }, - visitLiteralMap: function(ast) { - assert.argumentTypes(ast, LiteralMap); - return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, _mapPrimitiveName(ast.keys), ChangeDetectionUtil.mapFn(ast.keys), this._visitAll(ast.values), null, 0); + isKeywordNull: function() { + return (this.type == TOKEN_TYPE_KEYWORD && this.strValue == "null"); }, - visitBinary: function(ast) { - assert.argumentTypes(ast, Binary); - var left = ast.left.visit(this); - var right = ast.right.visit(this); - return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, _operationToPrimitiveName(ast.operation), _operationToFunction(ast.operation), [left, right], null, 0); + isKeywordUndefined: function() { + return (this.type == TOKEN_TYPE_KEYWORD && this.strValue == "undefined"); }, - visitPrefixNot: function(ast) { - assert.argumentTypes(ast, PrefixNot); - var exp = ast.expression.visit(this); - return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, "operation_negate", ChangeDetectionUtil.operation_negate, [exp], null, 0); + isKeywordTrue: function() { + return (this.type == TOKEN_TYPE_KEYWORD && this.strValue == "true"); }, - visitConditional: function(ast) { - assert.argumentTypes(ast, Conditional); - var c = ast.condition.visit(this); - var t = ast.trueExp.visit(this); - var f = ast.falseExp.visit(this); - return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, "cond", ChangeDetectionUtil.cond, [c, t, f], null, 0); + isKeywordFalse: function() { + return (this.type == TOKEN_TYPE_KEYWORD && this.strValue == "false"); }, - visitPipe: function(ast) { - assert.argumentTypes(ast, Pipe); - var value = ast.exp.visit(this); - var type = ast.inBinding ? RECORD_TYPE_BINDING_PIPE : RECORD_TYPE_PIPE; - return this._addRecord(type, ast.name, ast.name, [], null, value); + toNumber: function() { + return (this.type == TOKEN_TYPE_NUMBER) ? this.numValue : -1; }, - visitKeyedAccess: function(ast) { - assert.argumentTypes(ast, KeyedAccess); - var obj = ast.obj.visit(this); - var key = ast.key.visit(this); - return this._addRecord(RECORD_TYPE_KEYED_ACCESS, "keyedAccess", ChangeDetectionUtil.keyedAccess, [key], null, obj); + toString: function() { + var t = this.type; + if (t >= TOKEN_TYPE_CHARACTER && t <= TOKEN_TYPE_STRING) { + return this.strValue; + } else if (t == TOKEN_TYPE_NUMBER) { + return this.numValue.toString(); + } else { + return null; + } + } + }, {}); + }()); + $__export("Token", Token); + EOF = new Token(-1, 0, 0, ""); + $__export("EOF", EOF); + $EOF = 0; + $__export("$EOF", $EOF); + $TAB = 9; + $__export("$TAB", $TAB); + $LF = 10; + $__export("$LF", $LF); + $VTAB = 11; + $__export("$VTAB", $VTAB); + $FF = 12; + $__export("$FF", $FF); + $CR = 13; + $__export("$CR", $CR); + $SPACE = 32; + $__export("$SPACE", $SPACE); + $BANG = 33; + $__export("$BANG", $BANG); + $DQ = 34; + $__export("$DQ", $DQ); + $HASH = 35; + $__export("$HASH", $HASH); + $$ = 36; + $__export("$$", $$); + $PERCENT = 37; + $__export("$PERCENT", $PERCENT); + $AMPERSAND = 38; + $__export("$AMPERSAND", $AMPERSAND); + $SQ = 39; + $__export("$SQ", $SQ); + $LPAREN = 40; + $__export("$LPAREN", $LPAREN); + $RPAREN = 41; + $__export("$RPAREN", $RPAREN); + $STAR = 42; + $__export("$STAR", $STAR); + $PLUS = 43; + $__export("$PLUS", $PLUS); + $COMMA = 44; + $__export("$COMMA", $COMMA); + $MINUS = 45; + $__export("$MINUS", $MINUS); + $PERIOD = 46; + $__export("$PERIOD", $PERIOD); + $SLASH = 47; + $__export("$SLASH", $SLASH); + $COLON = 58; + $__export("$COLON", $COLON); + $SEMICOLON = 59; + $__export("$SEMICOLON", $SEMICOLON); + $LT = 60; + $__export("$LT", $LT); + $EQ = 61; + $__export("$EQ", $EQ); + $GT = 62; + $__export("$GT", $GT); + $QUESTION = 63; + $__export("$QUESTION", $QUESTION); + $0 = 48; + $9 = 57; + $A = 65, $E = 69, $Z = 90; + $LBRACKET = 91; + $__export("$LBRACKET", $LBRACKET); + $BACKSLASH = 92; + $__export("$BACKSLASH", $BACKSLASH); + $RBRACKET = 93; + $__export("$RBRACKET", $RBRACKET); + $CARET = 94; + $_ = 95; + $a = 97, $e = 101, $f = 102, $n = 110, $r = 114, $t = 116, $u = 117, $v = 118, $z = 122; + $LBRACE = 123; + $__export("$LBRACE", $LBRACE); + $BAR = 124; + $__export("$BAR", $BAR); + $RBRACE = 125; + $__export("$RBRACE", $RBRACE); + $NBSP = 160; + ScannerError = (function($__super) { + function ScannerError(message) { + $traceurRuntime.superConstructor(ScannerError).call(this); + this.message = message; + } + return ($traceurRuntime.createClass)(ScannerError, {toString: function() { + return this.message; + }}, {}, $__super); + }(BaseException)); + $__export("ScannerError", ScannerError); + _Scanner = (function() { + function _Scanner(input) { + this.input = input; + this.length = input.length; + this.peek = 0; + this.index = -1; + this.advance(); + } + return ($traceurRuntime.createClass)(_Scanner, { + advance: function() { + this.peek = ++this.index >= this.length ? $EOF : StringWrapper.charCodeAt(this.input, this.index); }, - _visitAll: function(asts) { - assert.argumentTypes(asts, List); - var res = ListWrapper.createFixedSize(asts.length); - for (var i = 0; i < asts.length; ++i) { - res[i] = asts[i].visit(this); + scanToken: function() { + var input = this.input, + length = this.length, + peek = this.peek, + index = this.index; + while (peek <= $SPACE) { + if (++index >= length) { + peek = $EOF; + break; + } else { + peek = StringWrapper.charCodeAt(input, index); + } + } + this.peek = peek; + this.index = index; + if (index >= length) { + return null; + } + if (isIdentifierStart(peek)) + return this.scanIdentifier(); + if (isDigit(peek)) + return this.scanNumber(index); + var start = index; + switch (peek) { + case $PERIOD: + this.advance(); + return isDigit(this.peek) ? this.scanNumber(start) : newCharacterToken(start, $PERIOD); + case $LPAREN: + case $RPAREN: + case $LBRACE: + case $RBRACE: + case $LBRACKET: + case $RBRACKET: + case $COMMA: + case $COLON: + case $SEMICOLON: + return this.scanCharacter(start, peek); + case $SQ: + case $DQ: + return this.scanString(); + case $HASH: + return this.scanOperator(start, StringWrapper.fromCharCode(peek)); + case $PLUS: + case $MINUS: + case $STAR: + case $SLASH: + case $PERCENT: + case $CARET: + case $QUESTION: + return this.scanOperator(start, StringWrapper.fromCharCode(peek)); + case $LT: + case $GT: + case $BANG: + case $EQ: + return this.scanComplexOperator(start, $EQ, StringWrapper.fromCharCode(peek), '='); + case $AMPERSAND: + return this.scanComplexOperator(start, $AMPERSAND, '&', '&'); + case $BAR: + return this.scanComplexOperator(start, $BAR, '|', '|'); + case $NBSP: + while (isWhitespace(this.peek)) + this.advance(); + return this.scanToken(); + } + this.error(("Unexpected character [" + StringWrapper.fromCharCode(peek) + "]"), 0); + return null; + }, + scanCharacter: function(start, code) { + assert(this.peek == code); + this.advance(); + return newCharacterToken(start, code); + }, + scanOperator: function(start, str) { + assert(this.peek == StringWrapper.charCodeAt(str, 0)); + assert(SetWrapper.has(OPERATORS, str)); + this.advance(); + return newOperatorToken(start, str); + }, + scanComplexOperator: function(start, code, one, two) { + assert(this.peek == StringWrapper.charCodeAt(one, 0)); + this.advance(); + var str = one; + while (this.peek == code) { + this.advance(); + str += two; } - return res; + assert(SetWrapper.has(OPERATORS, str)); + return newOperatorToken(start, str); }, - _addRecord: function(type, name, funcOrValue, args, fixedArgs, context) { - var selfIndex = ++this.contextIndex; - if (context instanceof DirectiveIndex) { - ListWrapper.push(this.protoRecords, new ProtoRecord(type, name, funcOrValue, args, fixedArgs, -1, context, selfIndex, this.bindingRecord, this.expressionAsString, false, false)); + scanIdentifier: function() { + assert(isIdentifierStart(this.peek)); + var start = this.index; + this.advance(); + while (isIdentifierPart(this.peek)) + this.advance(); + var str = this.input.substring(start, this.index); + if (SetWrapper.has(KEYWORDS, str)) { + return newKeywordToken(start, str); } else { - ListWrapper.push(this.protoRecords, new ProtoRecord(type, name, funcOrValue, args, fixedArgs, context, null, selfIndex, this.bindingRecord, this.expressionAsString, false, false)); + return newIdentifierToken(start, str); } - return selfIndex; - } - }, {convert: function(b, contextIndex, variableBindings) { - assert.argumentTypes(b, BindingRecord, contextIndex, assert.type.number, variableBindings, List); - var c = new _ConvertAstIntoProtoRecords(b, contextIndex, b.ast.toString(), variableBindings); - b.ast.visit(c); - return c.protoRecords; - }}); - }()); - Object.defineProperty(_ConvertAstIntoProtoRecords, "parameters", {get: function() { - return [[BindingRecord], [assert.type.number], [assert.type.string], [List]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.convert, "parameters", {get: function() { - return [[BindingRecord], [assert.type.number], [List]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitImplicitReceiver, "parameters", {get: function() { - return [[ImplicitReceiver]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitInterpolation, "parameters", {get: function() { - return [[Interpolation]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitLiteralPrimitive, "parameters", {get: function() { - return [[LiteralPrimitive]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitAccessMember, "parameters", {get: function() { - return [[AccessMember]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitMethodCall, "parameters", {get: function() { - return [[MethodCall]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitFunctionCall, "parameters", {get: function() { - return [[FunctionCall]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitLiteralArray, "parameters", {get: function() { - return [[LiteralArray]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitLiteralMap, "parameters", {get: function() { - return [[LiteralMap]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitBinary, "parameters", {get: function() { - return [[Binary]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitPrefixNot, "parameters", {get: function() { - return [[PrefixNot]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitConditional, "parameters", {get: function() { - return [[Conditional]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitPipe, "parameters", {get: function() { - return [[Pipe]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype.visitKeyedAccess, "parameters", {get: function() { - return [[KeyedAccess]]; - }}); - Object.defineProperty(_ConvertAstIntoProtoRecords.prototype._visitAll, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(_arrayFn, "parameters", {get: function() { - return [[assert.type.number]]; - }}); - Object.defineProperty(_mapPrimitiveName, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(_operationToPrimitiveName, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(_operationToFunction, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(_interpolationFn, "parameters", {get: function() { - return [[List]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/compiler/compile_pipeline", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/view/proto_view_builder"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/compile_pipeline"; - var assert, - isPresent, - List, - ListWrapper, - DOM, - CompileElement, - CompileControl, - CompileStep, - ProtoViewBuilder, - CompilePipeline; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - isPresent = $__m.isPresent; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - CompileElement = $__m.CompileElement; - }, function($__m) { - CompileControl = $__m.CompileControl; - }, function($__m) { - CompileStep = $__m.CompileStep; - }, function($__m) { - ProtoViewBuilder = $__m.ProtoViewBuilder; - }], - execute: function() { - CompilePipeline = (function() { - function CompilePipeline(steps) { - assert.argumentTypes(steps, assert.genericType(List, CompileStep)); - this._control = new CompileControl(steps); - } - return ($traceurRuntime.createClass)(CompilePipeline, { - process: function(rootElement) { - var compilationCtxtDescription = arguments[1] !== (void 0) ? arguments[1] : ''; - assert.argumentTypes(rootElement, assert.type.any, compilationCtxtDescription, assert.type.string); - var results = ListWrapper.create(); - var rootCompileElement = new CompileElement(rootElement, compilationCtxtDescription); - rootCompileElement.inheritedProtoView = new ProtoViewBuilder(rootElement); - rootCompileElement.isViewRoot = true; - this._process(results, null, rootCompileElement, compilationCtxtDescription); - return assert.returnType((results), List); }, - _process: function(results, parent, current) { - var compilationCtxtDescription = arguments[3] !== (void 0) ? arguments[3] : ''; - assert.argumentTypes(results, assert.type.any, parent, CompileElement, current, CompileElement, compilationCtxtDescription, assert.type.string); - var additionalChildren = this._control.internalProcess(results, 0, parent, current); - if (current.compileChildren) { - var node = DOM.firstChild(DOM.templateAwareRoot(current.element)); - while (isPresent(node)) { - var nextNode = DOM.nextSibling(node); - if (DOM.isElementNode(node)) { - var childCompileElement = new CompileElement(node, compilationCtxtDescription); - childCompileElement.inheritedProtoView = current.inheritedProtoView; - childCompileElement.inheritedElementBinder = current.inheritedElementBinder; - childCompileElement.distanceToInheritedBinder = current.distanceToInheritedBinder + 1; - this._process(results, current, childCompileElement); - } - node = nextNode; + scanNumber: function(start) { + assert(isDigit(this.peek)); + var simple = (this.index === start); + this.advance(); + while (true) { + if (isDigit(this.peek)) {} else if (this.peek == $PERIOD) { + simple = false; + } else if (isExponentStart(this.peek)) { + this.advance(); + if (isExponentSign(this.peek)) + this.advance(); + if (!isDigit(this.peek)) + this.error('Invalid exponent', -1); + simple = false; + } else { + break; } + this.advance(); } - if (isPresent(additionalChildren)) { - for (var i = 0; i < additionalChildren.length; i++) { - this._process(results, current, additionalChildren[i]); + var str = this.input.substring(start, this.index); + var value = simple ? NumberWrapper.parseIntAutoRadix(str) : NumberWrapper.parseFloat(str); + return newNumberToken(start, value); + }, + scanString: function() { + assert(this.peek == $SQ || this.peek == $DQ); + var start = this.index; + var quote = this.peek; + this.advance(); + var buffer; + var marker = this.index; + var input = this.input; + while (this.peek != quote) { + if (this.peek == $BACKSLASH) { + if (buffer == null) + buffer = new StringJoiner(); + buffer.add(input.substring(marker, this.index)); + this.advance(); + var unescapedCode = void 0; + if (this.peek == $u) { + var hex = input.substring(this.index + 1, this.index + 5); + try { + unescapedCode = NumberWrapper.parseInt(hex, 16); + } catch (e) { + this.error(("Invalid unicode escape [\\u" + hex + "]"), 0); + } + for (var i = 0; i < 5; i++) { + this.advance(); + } + } else { + unescapedCode = unescape(this.peek); + this.advance(); + } + buffer.add(StringWrapper.fromCharCode(unescapedCode)); + marker = this.index; + } else if (this.peek == $EOF) { + this.error('Unterminated quote', 0); + } else { + this.advance(); } } + var last = input.substring(marker, this.index); + this.advance(); + var unescaped = last; + if (buffer != null) { + buffer.add(last); + unescaped = buffer.toString(); + } + return newStringToken(start, unescaped); + }, + error: function(message, offset) { + var position = this.index + offset; + throw new ScannerError(("Lexer Error: " + message + " at column " + position + " in expression [" + this.input + "]")); } }, {}); }()); - $__export("CompilePipeline", CompilePipeline); - Object.defineProperty(CompilePipeline, "parameters", {get: function() { - return [[assert.genericType(List, CompileStep)]]; - }}); - Object.defineProperty(CompilePipeline.prototype.process, "parameters", {get: function() { - return [[], [assert.type.string]]; - }}); - Object.defineProperty(CompilePipeline.prototype._process, "parameters", {get: function() { - return [[], [CompileElement], [CompileElement], [assert.type.string]]; - }}); + OPERATORS = SetWrapper.createFromList(['+', '-', '*', '/', '%', '^', '=', '==', '!=', '===', '!==', '<', '>', '<=', '>=', '&&', '||', '&', '|', '!', '?', '#']); + KEYWORDS = SetWrapper.createFromList(['var', 'null', 'undefined', 'true', 'false']); } }; }); -System.register("angular2/src/di/injector", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/src/di/binding", "angular2/src/di/exceptions", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/di/key"], function($__export) { +System.register("angular2/src/change_detection/parser/parser", ["angular2/src/di/decorators", "angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/parser/lexer", "angular2/src/reflection/reflection", "angular2/src/change_detection/parser/ast"], function($__export) { "use strict"; - var __moduleName = "angular2/src/di/injector"; - var assert, - Map, - List, - MapWrapper, - ListWrapper, - ResolvedBinding, - Binding, - BindingBuilder, - bind, - AbstractBindingError, - NoBindingError, - AsyncBindingError, - CyclicDependencyError, - InstantiationError, - InvalidBindingError, - FunctionWrapper, - Type, - isPresent, + var __moduleName = "angular2/src/change_detection/parser/parser"; + var __decorate, + __metadata, + Injectable, isBlank, - Promise, - PromiseWrapper, - Key, - _constructing, - _notFound, - _Waiting, - Injector, - _SyncInjectorStrategy, - _AsyncInjectorStrategy; - function _isWaiting(obj) { - return assert.returnType((obj instanceof _Waiting), assert.type.boolean); - } - function _resolveBindings(bindings) { - assert.argumentTypes(bindings, List); - var resolvedList = ListWrapper.createFixedSize(bindings.length); - for (var i = 0; i < bindings.length; i++) { - var unresolved = bindings[i]; - var resolved = void 0; - if (unresolved instanceof ResolvedBinding) { - resolved = unresolved; - } else if (unresolved instanceof Type) { - resolved = bind(unresolved).toClass(unresolved).resolve(); - } else if (unresolved instanceof Binding) { - resolved = unresolved.resolve(); - } else if (unresolved instanceof List) { - resolved = _resolveBindings(unresolved); - } else if (unresolved instanceof BindingBuilder) { - throw new InvalidBindingError('BindingBuilder with ' + unresolved.token + ' token'); - } else { - throw new InvalidBindingError(unresolved); - } - resolvedList[i] = resolved; - } - return assert.returnType((resolvedList), List); - } - function _createListOfBindings(flattenedBindings) { - var bindings = ListWrapper.createFixedSize(Key.numberOfKeys + 1); - MapWrapper.forEach(flattenedBindings, (function(v, keyId) { - return bindings[keyId] = v; - })); - return assert.returnType((bindings), List); - } - function _flattenBindings(bindings, res) { - assert.argumentTypes(bindings, List, res, Map); - ListWrapper.forEach(bindings, function(b) { - if (b instanceof ResolvedBinding) { - MapWrapper.set(res, b.key.id, b); - } else if (b instanceof List) { - _flattenBindings(b, res); - } - }); - return assert.returnType((res), Map); - } + isPresent, + BaseException, + StringWrapper, + RegExpWrapper, + ListWrapper, + Lexer, + EOF, + $PERIOD, + $COLON, + $SEMICOLON, + $LBRACKET, + $RBRACKET, + $COMMA, + $LBRACE, + $RBRACE, + $LPAREN, + $RPAREN, + reflector, + Reflector, + EmptyExpr, + ImplicitReceiver, + AccessMember, + LiteralPrimitive, + Binary, + PrefixNot, + Conditional, + Pipe, + Assignment, + Chain, + KeyedAccess, + LiteralArray, + LiteralMap, + Interpolation, + MethodCall, + FunctionCall, + TemplateBinding, + ASTWithSource, + __esModule, + _implicitReceiver, + INTERPOLATION_REGEXP, + Parser, + _ParseAST; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Map = $__m.Map; - List = $__m.List; - MapWrapper = $__m.MapWrapper; - ListWrapper = $__m.ListWrapper; + Injectable = $__m.Injectable; }, function($__m) { - ResolvedBinding = $__m.ResolvedBinding; - Binding = $__m.Binding; - BindingBuilder = $__m.BindingBuilder; - bind = $__m.bind; + isBlank = $__m.isBlank; + isPresent = $__m.isPresent; + BaseException = $__m.BaseException; + StringWrapper = $__m.StringWrapper; + RegExpWrapper = $__m.RegExpWrapper; }, function($__m) { - AbstractBindingError = $__m.AbstractBindingError; - NoBindingError = $__m.NoBindingError; - AsyncBindingError = $__m.AsyncBindingError; - CyclicDependencyError = $__m.CyclicDependencyError; - InstantiationError = $__m.InstantiationError; - InvalidBindingError = $__m.InvalidBindingError; + ListWrapper = $__m.ListWrapper; }, function($__m) { - FunctionWrapper = $__m.FunctionWrapper; - Type = $__m.Type; - isPresent = $__m.isPresent; - isBlank = $__m.isBlank; + Lexer = $__m.Lexer; + EOF = $__m.EOF; + $PERIOD = $__m.$PERIOD; + $COLON = $__m.$COLON; + $SEMICOLON = $__m.$SEMICOLON; + $LBRACKET = $__m.$LBRACKET; + $RBRACKET = $__m.$RBRACKET; + $COMMA = $__m.$COMMA; + $LBRACE = $__m.$LBRACE; + $RBRACE = $__m.$RBRACE; + $LPAREN = $__m.$LPAREN; + $RPAREN = $__m.$RPAREN; }, function($__m) { - Promise = $__m.Promise; - PromiseWrapper = $__m.PromiseWrapper; + reflector = $__m.reflector; + Reflector = $__m.Reflector; }, function($__m) { - Key = $__m.Key; + EmptyExpr = $__m.EmptyExpr; + ImplicitReceiver = $__m.ImplicitReceiver; + AccessMember = $__m.AccessMember; + LiteralPrimitive = $__m.LiteralPrimitive; + Binary = $__m.Binary; + PrefixNot = $__m.PrefixNot; + Conditional = $__m.Conditional; + Pipe = $__m.Pipe; + Assignment = $__m.Assignment; + Chain = $__m.Chain; + KeyedAccess = $__m.KeyedAccess; + LiteralArray = $__m.LiteralArray; + LiteralMap = $__m.LiteralMap; + Interpolation = $__m.Interpolation; + MethodCall = $__m.MethodCall; + FunctionCall = $__m.FunctionCall; + TemplateBinding = $__m.TemplateBinding; + ASTWithSource = $__m.ASTWithSource; }], execute: function() { - _constructing = new Object(); - _notFound = new Object(); - _Waiting = (function() { - function _Waiting(promise) { - assert.argumentTypes(promise, Promise); - this.promise = promise; + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); } - return ($traceurRuntime.createClass)(_Waiting, {}, {}); - }()); - Object.defineProperty(_Waiting, "parameters", {get: function() { - return [[Promise]]; - }}); - Injector = (function() { - function Injector(bindings, parent, defaultBindings) { - assert.argumentTypes(bindings, assert.genericType(List, ResolvedBinding), parent, Injector, defaultBindings, assert.type.boolean); - this._bindings = bindings; - this._instances = this._createInstances(); - this._parent = parent; - this._defaultBindings = defaultBindings; - this._asyncStrategy = new _AsyncInjectorStrategy(this); - this._syncStrategy = new _SyncInjectorStrategy(this); + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + _implicitReceiver = new ImplicitReceiver(); + INTERPOLATION_REGEXP = RegExpWrapper.create('\\{\\{(.*?)\\}\\}'); + Parser = (($traceurRuntime.createClass)(function(lexer) { + var providedReflector = arguments[1] !== (void 0) ? arguments[1] : null; + this._lexer = lexer; + this._reflector = isPresent(providedReflector) ? providedReflector : reflector; + }, { + parseAction: function(input, location) { + var tokens = this._lexer.tokenize(input); + var ast = new _ParseAST(input, location, tokens, this._reflector, true).parseChain(); + return new ASTWithSource(ast, input, location); + }, + parseBinding: function(input, location) { + var tokens = this._lexer.tokenize(input); + var ast = new _ParseAST(input, location, tokens, this._reflector, false).parseChain(); + return new ASTWithSource(ast, input, location); + }, + addPipes: function(bindingAst, pipes) { + if (ListWrapper.isEmpty(pipes)) + return bindingAst; + var res = ListWrapper.reduce(pipes, (function(result, currentPipeName) { + return new Pipe(result, currentPipeName, [], false); + }), bindingAst.ast); + return new ASTWithSource(res, bindingAst.source, bindingAst.location); + }, + parseTemplateBindings: function(input, location) { + var tokens = this._lexer.tokenize(input); + return new _ParseAST(input, location, tokens, this._reflector, false).parseTemplateBindings(); + }, + parseInterpolation: function(input, location) { + var parts = StringWrapper.split(input, INTERPOLATION_REGEXP); + if (parts.length <= 1) { + return null; + } + var strings = []; + var expressions = []; + for (var i = 0; i < parts.length; i++) { + var part = parts[i]; + if (i % 2 === 0) { + ListWrapper.push(strings, part); + } else { + var tokens = this._lexer.tokenize(part); + var ast = new _ParseAST(input, location, tokens, this._reflector, false).parseChain(); + ListWrapper.push(expressions, ast); + } + } + return new ASTWithSource(new Interpolation(strings, expressions), input, location); + }, + wrapLiteralPrimitive: function(input, location) { + return new ASTWithSource(new LiteralPrimitive(input), input, location); } - return ($traceurRuntime.createClass)(Injector, { - get: function(token) { - return this._getByKey(Key.get(token), false, false, false); + }, {})); + $__export("Parser", Parser); + $__export("Parser", Parser = __decorate([Injectable(), __metadata('design:paramtypes', [Lexer, Reflector])], Parser)); + _ParseAST = (function() { + function _ParseAST(input, location, tokens, reflector, parseAction) { + this.input = input; + this.location = location; + this.tokens = tokens; + this.reflector = reflector; + this.parseAction = parseAction; + this.index = 0; + } + return ($traceurRuntime.createClass)(_ParseAST, { + peek: function(offset) { + var i = this.index + offset; + return i < this.tokens.length ? this.tokens[i] : EOF; }, - getOptional: function(token) { - return this._getByKey(Key.get(token), false, false, true); + get next() { + return this.peek(0); }, - asyncGet: function(token) { - return assert.returnType((this._getByKey(Key.get(token), true, false, false)), Promise); + get inputIndex() { + return (this.index < this.tokens.length) ? this.next.index : this.input.length; }, - resolveAndCreateChild: function(bindings) { - assert.argumentTypes(bindings, List); - return assert.returnType((new Injector(Injector.resolve(bindings), this, false)), Injector); + advance: function() { + this.index++; }, - createChildFromResolved: function(bindings) { - assert.argumentTypes(bindings, assert.genericType(List, ResolvedBinding)); - return assert.returnType((new Injector(bindings, this, false)), Injector); + optionalCharacter: function(code) { + if (this.next.isCharacter(code)) { + this.advance(); + return true; + } else { + return false; + } }, - _createInstances: function() { - return assert.returnType((ListWrapper.createFixedSize(Key.numberOfKeys + 1)), List); + optionalKeywordVar: function() { + if (this.peekKeywordVar()) { + this.advance(); + return true; + } else { + return false; + } }, - _getByKey: function(key, returnPromise, returnLazy, optional) { - var $__0 = this; - if (returnLazy) { - return (function() { - return $__0._getByKey(key, returnPromise, false, optional); - }); + peekKeywordVar: function() { + return this.next.isKeywordVar() || this.next.isOperator('#'); + }, + expectCharacter: function(code) { + if (this.optionalCharacter(code)) + return ; + this.error(("Missing expected " + StringWrapper.fromCharCode(code))); + }, + optionalOperator: function(op) { + if (this.next.isOperator(op)) { + this.advance(); + return true; + } else { + return false; } - var strategy = returnPromise ? this._asyncStrategy : this._syncStrategy; - var instance = strategy.readFromCache(key); - if (instance !== _notFound) - return instance; - instance = strategy.instantiate(key); - if (instance !== _notFound) - return instance; - if (isPresent(this._parent)) { - return this._parent._getByKey(key, returnPromise, returnLazy, optional); + }, + expectOperator: function(operator) { + if (this.optionalOperator(operator)) + return ; + this.error(("Missing expected operator " + operator)); + }, + expectIdentifierOrKeyword: function() { + var n = this.next; + if (!n.isIdentifier() && !n.isKeyword()) { + this.error(("Unexpected token " + n + ", expected identifier or keyword")); } - if (optional) { - return null; + this.advance(); + return n.toString(); + }, + expectIdentifierOrKeywordOrString: function() { + var n = this.next; + if (!n.isIdentifier() && !n.isKeyword() && !n.isString()) { + this.error(("Unexpected token " + n + ", expected identifier, keyword, or string")); + } + this.advance(); + return n.toString(); + }, + parseChain: function() { + var exprs = []; + while (this.index < this.tokens.length) { + var expr = this.parsePipe(); + ListWrapper.push(exprs, expr); + if (this.optionalCharacter($SEMICOLON)) { + if (!this.parseAction) { + this.error("Binding expression cannot contain chained expression"); + } + while (this.optionalCharacter($SEMICOLON)) {} + } else if (this.index < this.tokens.length) { + this.error(("Unexpected token '" + this.next + "'")); + } + } + if (exprs.length == 0) + return new EmptyExpr(); + if (exprs.length == 1) + return exprs[0]; + return new Chain(exprs); + }, + parsePipe: function() { + var result = this.parseExpression(); + if (this.optionalOperator("|")) { + return this.parseInlinedPipe(result); + } else { + return result; + } + }, + parseExpression: function() { + var start = this.inputIndex; + var result = this.parseConditional(); + while (this.next.isOperator('=')) { + if (!result.isAssignable) { + var end = this.inputIndex; + var expression = this.input.substring(start, end); + this.error(("Expression " + expression + " is not assignable")); + } + if (!this.parseAction) { + this.error("Binding expression cannot contain assignments"); + } + this.expectOperator('='); + result = new Assignment(result, this.parseConditional()); + } + return result; + }, + parseConditional: function() { + var start = this.inputIndex; + var result = this.parseLogicalOr(); + if (this.optionalOperator('?')) { + var yes = this.parseExpression(); + if (!this.optionalCharacter($COLON)) { + var end = this.inputIndex; + var expression = this.input.substring(start, end); + this.error(("Conditional expression " + expression + " requires all 3 expressions")); + } + var no = this.parseExpression(); + return new Conditional(result, yes, no); } else { - throw new NoBindingError(key); + return result; } }, - _resolveDependencies: function(key, binding, forceAsync) { - var $__0 = this; - try { - var getDependency = (function(d) { - return $__0._getByKey(d.key, forceAsync || d.asPromise, d.lazy, d.optional); - }); - return assert.returnType((ListWrapper.map(binding.dependencies, getDependency)), List); - } catch (e) { - this._clear(key); - if (e instanceof AbstractBindingError) - e.addKey(key); - throw e; + parseLogicalOr: function() { + var result = this.parseLogicalAnd(); + while (this.optionalOperator('||')) { + result = new Binary('||', result, this.parseLogicalAnd()); } + return result; }, - _getInstance: function(key) { - assert.argumentTypes(key, Key); - if (this._instances.length <= key.id) - return null; - return ListWrapper.get(this._instances, key.id); - }, - _setInstance: function(key, obj) { - assert.argumentTypes(key, Key, obj, assert.type.any); - ListWrapper.set(this._instances, key.id, obj); - }, - _getBinding: function(key) { - assert.argumentTypes(key, Key); - var binding = this._bindings.length <= key.id ? null : ListWrapper.get(this._bindings, key.id); - if (isBlank(binding) && this._defaultBindings) { - return bind(key.token).toClass(key.token).resolve(); - } else { - return binding; + parseLogicalAnd: function() { + var result = this.parseEquality(); + while (this.optionalOperator('&&')) { + result = new Binary('&&', result, this.parseEquality()); } + return result; }, - _markAsConstructing: function(key) { - assert.argumentTypes(key, Key); - this._setInstance(key, _constructing); + parseEquality: function() { + var result = this.parseRelational(); + while (true) { + if (this.optionalOperator('==')) { + result = new Binary('==', result, this.parseRelational()); + } else if (this.optionalOperator('===')) { + result = new Binary('===', result, this.parseRelational()); + } else if (this.optionalOperator('!=')) { + result = new Binary('!=', result, this.parseRelational()); + } else if (this.optionalOperator('!==')) { + result = new Binary('!==', result, this.parseRelational()); + } else { + return result; + } + } }, - _clear: function(key) { - assert.argumentTypes(key, Key); - this._setInstance(key, null); - } - }, { - resolve: function(bindings) { - assert.argumentTypes(bindings, List); - var resolvedBindings = _resolveBindings(bindings); - var flatten = _flattenBindings(resolvedBindings, MapWrapper.create()); - return assert.returnType((_createListOfBindings(flatten)), assert.genericType(List, ResolvedBinding)); + parseRelational: function() { + var result = this.parseAdditive(); + while (true) { + if (this.optionalOperator('<')) { + result = new Binary('<', result, this.parseAdditive()); + } else if (this.optionalOperator('>')) { + result = new Binary('>', result, this.parseAdditive()); + } else if (this.optionalOperator('<=')) { + result = new Binary('<=', result, this.parseAdditive()); + } else if (this.optionalOperator('>=')) { + result = new Binary('>=', result, this.parseAdditive()); + } else { + return result; + } + } }, - resolveAndCreate: function(bindings) { - var $__3; - var $__2 = arguments[1] !== (void 0) ? arguments[1] : {}, - defaultBindings = ($__3 = $__2.defaultBindings) === void 0 ? false : $__3; - assert.argumentTypes(bindings, List); - return assert.returnType((new Injector(Injector.resolve(bindings), null, defaultBindings)), Injector); + parseAdditive: function() { + var result = this.parseMultiplicative(); + while (true) { + if (this.optionalOperator('+')) { + result = new Binary('+', result, this.parseMultiplicative()); + } else if (this.optionalOperator('-')) { + result = new Binary('-', result, this.parseMultiplicative()); + } else { + return result; + } + } }, - fromResolvedBindings: function(bindings) { - var $__3; - var $__2 = arguments[1] !== (void 0) ? arguments[1] : {}, - defaultBindings = ($__3 = $__2.defaultBindings) === void 0 ? false : $__3; - assert.argumentTypes(bindings, assert.genericType(List, ResolvedBinding)); - return assert.returnType((new Injector(bindings, null, defaultBindings)), Injector); - } - }); - }()); - $__export("Injector", Injector); - Object.defineProperty(Injector, "parameters", {get: function() { - return [[assert.genericType(List, ResolvedBinding)], [Injector], [assert.type.boolean]]; - }}); - Object.defineProperty(Injector.resolve, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(Injector.resolveAndCreate, "parameters", {get: function() { - return [[List], []]; - }}); - Object.defineProperty(Injector.fromResolvedBindings, "parameters", {get: function() { - return [[assert.genericType(List, ResolvedBinding)], []]; - }}); - Object.defineProperty(Injector.prototype.resolveAndCreateChild, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(Injector.prototype.createChildFromResolved, "parameters", {get: function() { - return [[assert.genericType(List, ResolvedBinding)]]; - }}); - Object.defineProperty(Injector.prototype._getByKey, "parameters", {get: function() { - return [[Key], [assert.type.boolean], [assert.type.boolean], [assert.type.boolean]]; - }}); - Object.defineProperty(Injector.prototype._resolveDependencies, "parameters", {get: function() { - return [[Key], [ResolvedBinding], [assert.type.boolean]]; - }}); - Object.defineProperty(Injector.prototype._getInstance, "parameters", {get: function() { - return [[Key]]; - }}); - Object.defineProperty(Injector.prototype._setInstance, "parameters", {get: function() { - return [[Key], []]; - }}); - Object.defineProperty(Injector.prototype._getBinding, "parameters", {get: function() { - return [[Key]]; - }}); - Object.defineProperty(Injector.prototype._markAsConstructing, "parameters", {get: function() { - return [[Key]]; - }}); - Object.defineProperty(Injector.prototype._clear, "parameters", {get: function() { - return [[Key]]; - }}); - _SyncInjectorStrategy = (function() { - function _SyncInjectorStrategy(injector) { - assert.argumentTypes(injector, Injector); - this.injector = injector; - } - return ($traceurRuntime.createClass)(_SyncInjectorStrategy, { - readFromCache: function(key) { - assert.argumentTypes(key, Key); - if (key.token === Injector) { - return this.injector; + parseMultiplicative: function() { + var result = this.parsePrefix(); + while (true) { + if (this.optionalOperator('*')) { + result = new Binary('*', result, this.parsePrefix()); + } else if (this.optionalOperator('%')) { + result = new Binary('%', result, this.parsePrefix()); + } else if (this.optionalOperator('/')) { + result = new Binary('/', result, this.parsePrefix()); + } else { + return result; + } } - var instance = this.injector._getInstance(key); - if (instance === _constructing) { - throw new CyclicDependencyError(key); - } else if (isPresent(instance) && !_isWaiting(instance)) { - return instance; + }, + parsePrefix: function() { + if (this.optionalOperator('+')) { + return this.parsePrefix(); + } else if (this.optionalOperator('-')) { + return new Binary('-', new LiteralPrimitive(0), this.parsePrefix()); + } else if (this.optionalOperator('!')) { + return new PrefixNot(this.parsePrefix()); } else { - return _notFound; + return this.parseCallChain(); } }, - instantiate: function(key) { - assert.argumentTypes(key, Key); - var binding = this.injector._getBinding(key); - if (isBlank(binding)) - return _notFound; - if (binding.providedAsPromise) - throw new AsyncBindingError(key); - this.injector._markAsConstructing(key); - var deps = this.injector._resolveDependencies(key, binding, false); - return this._createInstance(key, binding, deps); - }, - _createInstance: function(key, binding, deps) { - assert.argumentTypes(key, Key, binding, ResolvedBinding, deps, List); - try { - var instance = FunctionWrapper.apply(binding.factory, deps); - this.injector._setInstance(key, instance); - return instance; - } catch (e) { - this.injector._clear(key); - throw new InstantiationError(e, key); - } - } - }, {}); - }()); - Object.defineProperty(_SyncInjectorStrategy, "parameters", {get: function() { - return [[Injector]]; - }}); - Object.defineProperty(_SyncInjectorStrategy.prototype.readFromCache, "parameters", {get: function() { - return [[Key]]; - }}); - Object.defineProperty(_SyncInjectorStrategy.prototype.instantiate, "parameters", {get: function() { - return [[Key]]; - }}); - Object.defineProperty(_SyncInjectorStrategy.prototype._createInstance, "parameters", {get: function() { - return [[Key], [ResolvedBinding], [List]]; - }}); - _AsyncInjectorStrategy = (function() { - function _AsyncInjectorStrategy(injector) { - assert.argumentTypes(injector, Injector); - this.injector = injector; - } - return ($traceurRuntime.createClass)(_AsyncInjectorStrategy, { - readFromCache: function(key) { - assert.argumentTypes(key, Key); - if (key.token === Injector) { - return PromiseWrapper.resolve(this.injector); + parseCallChain: function() { + var result = this.parsePrimary(); + while (true) { + if (this.optionalCharacter($PERIOD)) { + result = this.parseAccessMemberOrMethodCall(result); + } else if (this.optionalCharacter($LBRACKET)) { + var key = this.parseExpression(); + this.expectCharacter($RBRACKET); + result = new KeyedAccess(result, key); + } else if (this.optionalCharacter($LPAREN)) { + var args = this.parseCallArguments(); + this.expectCharacter($RPAREN); + result = new FunctionCall(result, args); + } else { + return result; + } } - var instance = this.injector._getInstance(key); - if (instance === _constructing) { - throw new CyclicDependencyError(key); - } else if (_isWaiting(instance)) { - return instance.promise; - } else if (isPresent(instance)) { - return PromiseWrapper.resolve(instance); + }, + parsePrimary: function() { + if (this.optionalCharacter($LPAREN)) { + var result = this.parsePipe(); + this.expectCharacter($RPAREN); + return result; + } else if (this.next.isKeywordNull() || this.next.isKeywordUndefined()) { + this.advance(); + return new LiteralPrimitive(null); + } else if (this.next.isKeywordTrue()) { + this.advance(); + return new LiteralPrimitive(true); + } else if (this.next.isKeywordFalse()) { + this.advance(); + return new LiteralPrimitive(false); + } else if (this.optionalCharacter($LBRACKET)) { + var elements = this.parseExpressionList($RBRACKET); + this.expectCharacter($RBRACKET); + return new LiteralArray(elements); + } else if (this.next.isCharacter($LBRACE)) { + return this.parseLiteralMap(); + } else if (this.next.isIdentifier()) { + return this.parseAccessMemberOrMethodCall(_implicitReceiver); + } else if (this.next.isNumber()) { + var value = this.next.toNumber(); + this.advance(); + return new LiteralPrimitive(value); + } else if (this.next.isString()) { + var literalValue = this.next.toString(); + this.advance(); + return new LiteralPrimitive(literalValue); + } else if (this.index >= this.tokens.length) { + this.error(("Unexpected end of expression: " + this.input)); } else { - return _notFound; + this.error(("Unexpected token " + this.next)); } }, - instantiate: function(key) { - var $__0 = this; - var binding = this.injector._getBinding(key); - if (isBlank(binding)) - return _notFound; - this.injector._markAsConstructing(key); - var deps = this.injector._resolveDependencies(key, binding, true); - var depsPromise = PromiseWrapper.all(deps); - var promise = PromiseWrapper.then(depsPromise, null, (function(e) { - return $__0._errorHandler(key, e); - })).then((function(deps) { - return $__0._findOrCreate(key, binding, deps); - })).then((function(instance) { - return $__0._cacheInstance(key, instance); - })); - this.injector._setInstance(key, new _Waiting(promise)); - return promise; + parseExpressionList: function(terminator) { + var result = []; + if (!this.next.isCharacter(terminator)) { + do { + ListWrapper.push(result, this.parseExpression()); + } while (this.optionalCharacter($COMMA)); + } + return result; }, - _errorHandler: function(key, e) { - assert.argumentTypes(key, Key, e, assert.type.any); - if (e instanceof AbstractBindingError) - e.addKey(key); - return assert.returnType((PromiseWrapper.reject(e)), Promise); + parseLiteralMap: function() { + var keys = []; + var values = []; + this.expectCharacter($LBRACE); + if (!this.optionalCharacter($RBRACE)) { + do { + var key = this.expectIdentifierOrKeywordOrString(); + ListWrapper.push(keys, key); + this.expectCharacter($COLON); + ListWrapper.push(values, this.parseExpression()); + } while (this.optionalCharacter($COMMA)); + this.expectCharacter($RBRACE); + } + return new LiteralMap(keys, values); }, - _findOrCreate: function(key, binding, deps) { - assert.argumentTypes(key, Key, binding, ResolvedBinding, deps, List); - try { - var instance = this.injector._getInstance(key); - if (!_isWaiting(instance)) - return instance; - return FunctionWrapper.apply(binding.factory, deps); - } catch (e) { - this.injector._clear(key); - throw new InstantiationError(e, key); + parseAccessMemberOrMethodCall: function(receiver) { + var id = this.expectIdentifierOrKeyword(); + if (this.optionalCharacter($LPAREN)) { + var args = this.parseCallArguments(); + this.expectCharacter($RPAREN); + var fn = this.reflector.method(id); + return new MethodCall(receiver, id, fn, args); + } else { + var getter = this.reflector.getter(id); + var setter = this.reflector.setter(id); + var am = new AccessMember(receiver, id, getter, setter); + if (this.optionalOperator("|")) { + return this.parseInlinedPipe(am); + } else { + return am; + } } }, - _cacheInstance: function(key, instance) { - this.injector._setInstance(key, instance); - return instance; - } - }, {}); - }()); - Object.defineProperty(_AsyncInjectorStrategy, "parameters", {get: function() { - return [[Injector]]; - }}); - Object.defineProperty(_AsyncInjectorStrategy.prototype.readFromCache, "parameters", {get: function() { - return [[Key]]; - }}); - Object.defineProperty(_AsyncInjectorStrategy.prototype.instantiate, "parameters", {get: function() { - return [[Key]]; - }}); - Object.defineProperty(_AsyncInjectorStrategy.prototype._errorHandler, "parameters", {get: function() { - return [[Key], []]; - }}); - Object.defineProperty(_AsyncInjectorStrategy.prototype._findOrCreate, "parameters", {get: function() { - return [[Key], [ResolvedBinding], [List]]; - }}); - Object.defineProperty(_resolveBindings, "parameters", {get: function() { - return [[List]]; - }}); - Object.defineProperty(_flattenBindings, "parameters", {get: function() { - return [[List], [Map]]; - }}); - } - }; -}); - -System.register("angular2/src/change_detection/exceptions", ["rtts_assert/rtts_assert", "angular2/src/change_detection/proto_record"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/change_detection/exceptions"; - var assert, - ProtoRecord, - ExpressionChangedAfterItHasBeenChecked, - ChangeDetectionError; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - ProtoRecord = $__m.ProtoRecord; - }], - execute: function() { - ExpressionChangedAfterItHasBeenChecked = (function($__super) { - function ExpressionChangedAfterItHasBeenChecked(proto, change) { - assert.argumentTypes(proto, ProtoRecord, change, assert.type.any); - $traceurRuntime.superConstructor(ExpressionChangedAfterItHasBeenChecked).call(this); - this.message = ("Expression '" + proto.expressionAsString + "' has changed after it was checked. ") + ("Previous value: '" + change.previousValue + "'. Current value: '" + change.currentValue + "'"); - } - return ($traceurRuntime.createClass)(ExpressionChangedAfterItHasBeenChecked, {toString: function() { - return assert.returnType((this.message), assert.type.string); - }}, {}, $__super); - }(Error)); - $__export("ExpressionChangedAfterItHasBeenChecked", ExpressionChangedAfterItHasBeenChecked); - Object.defineProperty(ExpressionChangedAfterItHasBeenChecked, "parameters", {get: function() { - return [[ProtoRecord], [assert.type.any]]; - }}); - ChangeDetectionError = (function($__super) { - function ChangeDetectionError(proto, originalException) { - assert.argumentTypes(proto, ProtoRecord, originalException, assert.type.any); - $traceurRuntime.superConstructor(ChangeDetectionError).call(this); - this.originalException = originalException; - this.location = proto.expressionAsString; - this.message = (this.originalException + " in [" + this.location + "]"); - } - return ($traceurRuntime.createClass)(ChangeDetectionError, {toString: function() { - return assert.returnType((this.message), assert.type.string); - }}, {}, $__super); - }(Error)); - $__export("ChangeDetectionError", ChangeDetectionError); - Object.defineProperty(ChangeDetectionError, "parameters", {get: function() { - return [[ProtoRecord], [assert.type.any]]; - }}); - } - }; -}); - -System.register("angular2/src/render/dom/compiler/compiler", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/async", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/render/api", "angular2/src/render/dom/compiler/compile_pipeline", "angular2/src/render/dom/compiler/template_loader", "angular2/src/render/dom/compiler/compile_step_factory", "angular2/change_detection", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { - "use strict"; - var __moduleName = "angular2/src/render/dom/compiler/compiler"; - var assert, - Injectable, - PromiseWrapper, - Promise, - BaseException, - DOM, - ViewDefinition, - ProtoViewDto, - DirectiveMetadata, - CompilePipeline, - TemplateLoader, - CompileStepFactory, - DefaultStepFactory, - Parser, - ShadowDomStrategy, - Compiler, - DefaultCompiler; - return { - setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { - PromiseWrapper = $__m.PromiseWrapper; - Promise = $__m.Promise; - }, function($__m) { - BaseException = $__m.BaseException; - }, function($__m) { - DOM = $__m.DOM; - }, function($__m) { - ViewDefinition = $__m.ViewDefinition; - ProtoViewDto = $__m.ProtoViewDto; - DirectiveMetadata = $__m.DirectiveMetadata; - }, function($__m) { - CompilePipeline = $__m.CompilePipeline; - }, function($__m) { - TemplateLoader = $__m.TemplateLoader; - }, function($__m) { - CompileStepFactory = $__m.CompileStepFactory; - DefaultStepFactory = $__m.DefaultStepFactory; - }, function($__m) { - Parser = $__m.Parser; - }, function($__m) { - ShadowDomStrategy = $__m.ShadowDomStrategy; - }], - execute: function() { - Compiler = (function() { - function Compiler(stepFactory, templateLoader) { - assert.argumentTypes(stepFactory, CompileStepFactory, templateLoader, TemplateLoader); - this._templateLoader = templateLoader; - this._stepFactory = stepFactory; - } - return ($traceurRuntime.createClass)(Compiler, { - compile: function(template) { - var $__0 = this; - var tplPromise = this._templateLoader.load(template); - return assert.returnType((PromiseWrapper.then(tplPromise, (function(el) { - return $__0._compileTemplate(template, el); - }), (function(_) { - throw new BaseException(("Failed to load the template \"" + template.componentId + "\"")); - }))), assert.genericType(Promise, ProtoViewDto)); + parseInlinedPipe: function(result) { + do { + if (this.parseAction) { + this.error("Cannot have a pipe in an action expression"); + } + var name = this.expectIdentifierOrKeyword(); + var args = ListWrapper.create(); + while (this.optionalCharacter($COLON)) { + ListWrapper.push(args, this.parseExpression()); + } + result = new Pipe(result, name, args, true); + } while (this.optionalOperator("|")); + return result; }, - compileHost: function(directiveMetadata) { - assert.argumentTypes(directiveMetadata, DirectiveMetadata); - var hostViewDef = new ViewDefinition({ - componentId: directiveMetadata.id, - absUrl: null, - template: null, - directives: [directiveMetadata] - }); - var element = DOM.createElement(directiveMetadata.selector); - return assert.returnType((this._compileTemplate(hostViewDef, element)), assert.genericType(Promise, ProtoViewDto)); + parseCallArguments: function() { + if (this.next.isCharacter($RPAREN)) + return []; + var positionals = []; + do { + ListWrapper.push(positionals, this.parseExpression()); + } while (this.optionalCharacter($COMMA)); + return positionals; }, - _compileTemplate: function(viewDef, tplElement) { - var subTaskPromises = []; - var pipeline = new CompilePipeline(this._stepFactory.createSteps(viewDef, subTaskPromises)); - var compileElements = pipeline.process(tplElement, viewDef.componentId); - var protoView = compileElements[0].inheritedProtoView.build(); - if (subTaskPromises.length > 0) { - return assert.returnType((PromiseWrapper.all(subTaskPromises).then((function(_) { - return protoView; - }))), assert.genericType(Promise, ProtoViewDto)); - } else { - return assert.returnType((PromiseWrapper.resolve(protoView)), assert.genericType(Promise, ProtoViewDto)); + expectTemplateBindingKey: function() { + var result = ''; + var operatorFound = false; + do { + result += this.expectIdentifierOrKeywordOrString(); + operatorFound = this.optionalOperator('-'); + if (operatorFound) { + result += '-'; + } + } while (operatorFound); + return result.toString(); + }, + parseTemplateBindings: function() { + var bindings = []; + var prefix = null; + while (this.index < this.tokens.length) { + var keyIsVar = this.optionalKeywordVar(); + var key = this.expectTemplateBindingKey(); + if (!keyIsVar) { + if (prefix == null) { + prefix = key; + } else { + key = prefix + '-' + key; + } + } + this.optionalCharacter($COLON); + var name = null; + var expression = null; + if (this.next !== EOF) { + if (keyIsVar) { + if (this.optionalOperator("=")) { + name = this.expectTemplateBindingKey(); + } else { + name = '\$implicit'; + } + } else if (!this.peekKeywordVar()) { + var start = this.inputIndex; + var ast = this.parsePipe(); + var source = this.input.substring(start, this.inputIndex); + expression = new ASTWithSource(ast, source, this.location); + } + } + ListWrapper.push(bindings, new TemplateBinding(key, keyIsVar, name, expression)); + if (!this.optionalCharacter($SEMICOLON)) { + this.optionalCharacter($COMMA); + } } + return bindings; + }, + error: function(message) { + var index = arguments[1] !== (void 0) ? arguments[1] : null; + if (isBlank(index)) + index = this.index; + var location = (index < this.tokens.length) ? ("at column " + (this.tokens[index].index + 1) + " in") : "at the end of the expression"; + throw new BaseException(("Parser Error: " + message + " " + location + " [" + this.input + "] in " + this.location)); } }, {}); }()); - $__export("Compiler", Compiler); - Object.defineProperty(Compiler, "parameters", {get: function() { - return [[CompileStepFactory], [TemplateLoader]]; - }}); - Object.defineProperty(Compiler.prototype.compile, "parameters", {get: function() { - return [[ViewDefinition]]; - }}); - Object.defineProperty(Compiler.prototype.compileHost, "parameters", {get: function() { - return [[DirectiveMetadata]]; - }}); - Object.defineProperty(Compiler.prototype._compileTemplate, "parameters", {get: function() { - return [[ViewDefinition], []]; - }}); - DefaultCompiler = (function($__super) { - function DefaultCompiler(parser, shadowDomStrategy, templateLoader) { - assert.argumentTypes(parser, Parser, shadowDomStrategy, ShadowDomStrategy, templateLoader, TemplateLoader); - $traceurRuntime.superConstructor(DefaultCompiler).call(this, new DefaultStepFactory(parser, shadowDomStrategy), templateLoader); - } - return ($traceurRuntime.createClass)(DefaultCompiler, {}, {}, $__super); - }(Compiler)); - $__export("DefaultCompiler", DefaultCompiler); - Object.defineProperty(DefaultCompiler, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(DefaultCompiler, "parameters", {get: function() { - return [[Parser], [ShadowDomStrategy], [TemplateLoader]]; - }}); } }; }); -System.register("angular2/di", ["angular2/src/di/annotations", "angular2/src/di/injector", "angular2/src/di/binding", "angular2/src/di/key", "angular2/src/di/exceptions", "angular2/src/di/opaque_token"], function($__export) { - "use strict"; - var __moduleName = "angular2/di"; - return { - setters: [function($__m) { - $__export("Inject", $__m.Inject); - $__export("InjectPromise", $__m.InjectPromise); - $__export("InjectLazy", $__m.InjectLazy); - $__export("Injectable", $__m.Injectable); - $__export("Optional", $__m.Optional); - $__export("DependencyAnnotation", $__m.DependencyAnnotation); - }, function($__m) { - $__export("Injector", $__m.Injector); - }, function($__m) { - $__export("Binding", $__m.Binding); - $__export("ResolvedBinding", $__m.ResolvedBinding); - $__export("Dependency", $__m.Dependency); - $__export("bind", $__m.bind); - }, function($__m) { - $__export("Key", $__m.Key); - $__export("KeyRegistry", $__m.KeyRegistry); - }, function($__m) { - $__export("KeyMetadataError", $__m.KeyMetadataError); - $__export("NoBindingError", $__m.NoBindingError); - $__export("AbstractBindingError", $__m.AbstractBindingError); - $__export("AsyncBindingError", $__m.AsyncBindingError); - $__export("CyclicDependencyError", $__m.CyclicDependencyError); - $__export("InstantiationError", $__m.InstantiationError); - $__export("InvalidBindingError", $__m.InvalidBindingError); - $__export("NoAnnotationError", $__m.NoAnnotationError); - }, function($__m) { - $__export("OpaqueToken", $__m.OpaqueToken); - }], - execute: function() {} - }; -}); - -System.register("angular2/src/render/dom/direct_dom_renderer", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/async", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/render/api", "angular2/src/render/dom/view/view", "angular2/src/render/dom/view/proto_view", "angular2/src/render/dom/view/view_factory", "angular2/src/render/dom/view/view_hydrator", "angular2/src/render/dom/compiler/compiler", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/view/proto_view_builder", "angular2/src/render/dom/view/view_container"], function($__export) { +System.register("angular2/src/change_detection/proto_change_detector", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/change_detection/parser/ast", "angular2/src/change_detection/interfaces", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/dynamic_change_detector", "angular2/src/change_detection/change_detection_jit_generator", "angular2/src/change_detection/directive_record", "angular2/src/change_detection/coalesce", "angular2/src/change_detection/proto_record"], function($__export) { "use strict"; - var __moduleName = "angular2/src/render/dom/direct_dom_renderer"; - var assert, - Injectable, - Promise, - PromiseWrapper, - List, - ListWrapper, + var __moduleName = "angular2/src/change_detection/proto_change_detector"; + var isPresent, isBlank, - isPresent, BaseException, - api, - RenderView, - RenderProtoView, - ViewFactory, - RenderViewHydrator, - Compiler, - ShadowDomStrategy, - ProtoViewBuilder, - ViewContainer, - DirectDomProtoViewRef, - DirectDomViewRef, - DirectDomRenderer; - function _resolveViewContainer(vc) { - assert.argumentTypes(vc, api.RenderViewContainerRef); - return _resolveView(vc.view).getOrCreateViewContainer(vc.elementIndex); + isString, + ListWrapper, + ImplicitReceiver, + ProtoChangeDetector, + ChangeDetectionUtil, + DynamicChangeDetector, + ChangeDetectorJITGenerator, + DirectiveIndex, + coalesce, + ProtoRecord, + RECORD_TYPE_PROPERTY, + RECORD_TYPE_LOCAL, + RECORD_TYPE_INVOKE_METHOD, + RECORD_TYPE_CONST, + RECORD_TYPE_INVOKE_CLOSURE, + RECORD_TYPE_PRIMITIVE_OP, + RECORD_TYPE_KEYED_ACCESS, + RECORD_TYPE_PIPE, + RECORD_TYPE_BINDING_PIPE, + RECORD_TYPE_INTERPOLATE, + __esModule, + DynamicProtoChangeDetector, + _jitProtoChangeDetectorClassCounter, + JitProtoChangeDetector, + ProtoRecordBuilder, + _ConvertAstIntoProtoRecords; + function _arrayFn(length) { + switch (length) { + case 0: + return ChangeDetectionUtil.arrayFn0; + case 1: + return ChangeDetectionUtil.arrayFn1; + case 2: + return ChangeDetectionUtil.arrayFn2; + case 3: + return ChangeDetectionUtil.arrayFn3; + case 4: + return ChangeDetectionUtil.arrayFn4; + case 5: + return ChangeDetectionUtil.arrayFn5; + case 6: + return ChangeDetectionUtil.arrayFn6; + case 7: + return ChangeDetectionUtil.arrayFn7; + case 8: + return ChangeDetectionUtil.arrayFn8; + case 9: + return ChangeDetectionUtil.arrayFn9; + default: + throw new BaseException("Does not support literal maps with more than 9 elements"); + } + } + function _mapPrimitiveName(keys) { + var stringifiedKeys = ListWrapper.join(ListWrapper.map(keys, (function(k) { + return isString(k) ? ("\"" + k + "\"") : ("" + k); + })), ", "); + return ("mapFn([" + stringifiedKeys + "])"); } - function _resolveView(viewRef) { - assert.argumentTypes(viewRef, DirectDomViewRef); - return isPresent(viewRef) ? viewRef.delegate : null; + function _operationToPrimitiveName(operation) { + switch (operation) { + case '+': + return "operation_add"; + case '-': + return "operation_subtract"; + case '*': + return "operation_multiply"; + case '/': + return "operation_divide"; + case '%': + return "operation_remainder"; + case '==': + return "operation_equals"; + case '!=': + return "operation_not_equals"; + case '<': + return "operation_less_then"; + case '>': + return "operation_greater_then"; + case '<=': + return "operation_less_or_equals_then"; + case '>=': + return "operation_greater_or_equals_then"; + case '&&': + return "operation_logical_and"; + case '||': + return "operation_logical_or"; + default: + throw new BaseException(("Unsupported operation " + operation)); + } } - function _resolveProtoView(protoViewRef) { - assert.argumentTypes(protoViewRef, DirectDomProtoViewRef); - return isPresent(protoViewRef) ? protoViewRef.delegate : null; + function _operationToFunction(operation) { + switch (operation) { + case '+': + return ChangeDetectionUtil.operation_add; + case '-': + return ChangeDetectionUtil.operation_subtract; + case '*': + return ChangeDetectionUtil.operation_multiply; + case '/': + return ChangeDetectionUtil.operation_divide; + case '%': + return ChangeDetectionUtil.operation_remainder; + case '==': + return ChangeDetectionUtil.operation_equals; + case '!=': + return ChangeDetectionUtil.operation_not_equals; + case '<': + return ChangeDetectionUtil.operation_less_then; + case '>': + return ChangeDetectionUtil.operation_greater_then; + case '<=': + return ChangeDetectionUtil.operation_less_or_equals_then; + case '>=': + return ChangeDetectionUtil.operation_greater_or_equals_then; + case '&&': + return ChangeDetectionUtil.operation_logical_and; + case '||': + return ChangeDetectionUtil.operation_logical_or; + default: + throw new BaseException(("Unsupported operation " + operation)); + } } - function _wrapView(view) { - assert.argumentTypes(view, RenderView); - return new DirectDomViewRef(view); + function s(v) { + return isPresent(v) ? ("" + v) : ''; } - function _collectComponentChildViewRefs(view) { - var target = arguments[1] !== (void 0) ? arguments[1] : null; - if (isBlank(target)) { - target = []; - } - ListWrapper.push(target, _wrapView(view)); - ListWrapper.forEach(view.componentChildViews, (function(view) { - if (isPresent(view)) { - _collectComponentChildViewRefs(view, target); - } - })); - return target; + function _interpolationFn(strings) { + var length = strings.length; + var c0 = length > 0 ? strings[0] : null; + var c1 = length > 1 ? strings[1] : null; + var c2 = length > 2 ? strings[2] : null; + var c3 = length > 3 ? strings[3] : null; + var c4 = length > 4 ? strings[4] : null; + var c5 = length > 5 ? strings[5] : null; + var c6 = length > 6 ? strings[6] : null; + var c7 = length > 7 ? strings[7] : null; + var c8 = length > 8 ? strings[8] : null; + var c9 = length > 9 ? strings[9] : null; + switch (length - 1) { + case 1: + return (function(a1) { + return c0 + s(a1) + c1; + }); + case 2: + return (function(a1, a2) { + return c0 + s(a1) + c1 + s(a2) + c2; + }); + case 3: + return (function(a1, a2, a3) { + return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3; + }); + case 4: + return (function(a1, a2, a3, a4) { + return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4; + }); + case 5: + return (function(a1, a2, a3, a4, a5) { + return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5; + }); + case 6: + return (function(a1, a2, a3, a4, a5, a6) { + return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6; + }); + case 7: + return (function(a1, a2, a3, a4, a5, a6, a7) { + return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6 + s(a7) + c7; + }); + case 8: + return (function(a1, a2, a3, a4, a5, a6, a7, a8) { + return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6 + s(a7) + c7 + s(a8) + c8; + }); + case 9: + return (function(a1, a2, a3, a4, a5, a6, a7, a8, a9) { + return c0 + s(a1) + c1 + s(a2) + c2 + s(a3) + c3 + s(a4) + c4 + s(a5) + c5 + s(a6) + c6 + s(a7) + c7 + s(a8) + c8 + s(a9) + c9; + }); + default: + throw new BaseException("Does not support more than 9 expressions"); + } } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { - Promise = $__m.Promise; - PromiseWrapper = $__m.PromiseWrapper; - }, function($__m) { - List = $__m.List; - ListWrapper = $__m.ListWrapper; - }, function($__m) { - isBlank = $__m.isBlank; isPresent = $__m.isPresent; + isBlank = $__m.isBlank; BaseException = $__m.BaseException; + isString = $__m.isString; }, function($__m) { - api = $__m; + ListWrapper = $__m.ListWrapper; }, function($__m) { - RenderView = $__m.RenderView; + ImplicitReceiver = $__m.ImplicitReceiver; }, function($__m) { - RenderProtoView = $__m.RenderProtoView; + ProtoChangeDetector = $__m.ProtoChangeDetector; }, function($__m) { - ViewFactory = $__m.ViewFactory; + ChangeDetectionUtil = $__m.ChangeDetectionUtil; }, function($__m) { - RenderViewHydrator = $__m.RenderViewHydrator; + DynamicChangeDetector = $__m.DynamicChangeDetector; }, function($__m) { - Compiler = $__m.Compiler; + ChangeDetectorJITGenerator = $__m.ChangeDetectorJITGenerator; }, function($__m) { - ShadowDomStrategy = $__m.ShadowDomStrategy; + DirectiveIndex = $__m.DirectiveIndex; }, function($__m) { - ProtoViewBuilder = $__m.ProtoViewBuilder; + coalesce = $__m.coalesce; }, function($__m) { - ViewContainer = $__m.ViewContainer; + ProtoRecord = $__m.ProtoRecord; + RECORD_TYPE_PROPERTY = $__m.RECORD_TYPE_PROPERTY; + RECORD_TYPE_LOCAL = $__m.RECORD_TYPE_LOCAL; + RECORD_TYPE_INVOKE_METHOD = $__m.RECORD_TYPE_INVOKE_METHOD; + RECORD_TYPE_CONST = $__m.RECORD_TYPE_CONST; + RECORD_TYPE_INVOKE_CLOSURE = $__m.RECORD_TYPE_INVOKE_CLOSURE; + RECORD_TYPE_PRIMITIVE_OP = $__m.RECORD_TYPE_PRIMITIVE_OP; + RECORD_TYPE_KEYED_ACCESS = $__m.RECORD_TYPE_KEYED_ACCESS; + RECORD_TYPE_PIPE = $__m.RECORD_TYPE_PIPE; + RECORD_TYPE_BINDING_PIPE = $__m.RECORD_TYPE_BINDING_PIPE; + RECORD_TYPE_INTERPOLATE = $__m.RECORD_TYPE_INTERPOLATE; }], execute: function() { - Object.defineProperty(_resolveViewContainer, "parameters", {get: function() { - return [[api.RenderViewContainerRef]]; - }}); - Object.defineProperty(_resolveView, "parameters", {get: function() { - return [[DirectDomViewRef]]; - }}); - Object.defineProperty(_resolveProtoView, "parameters", {get: function() { - return [[DirectDomProtoViewRef]]; - }}); - Object.defineProperty(_wrapView, "parameters", {get: function() { - return [[RenderView]]; - }}); - DirectDomProtoViewRef = (function($__super) { - function DirectDomProtoViewRef(delegate) { - assert.argumentTypes(delegate, RenderProtoView); - $traceurRuntime.superConstructor(DirectDomProtoViewRef).call(this); - this.delegate = delegate; - } - return ($traceurRuntime.createClass)(DirectDomProtoViewRef, {}, {}, $__super); - }(api.RenderProtoViewRef)); - $__export("DirectDomProtoViewRef", DirectDomProtoViewRef); - Object.defineProperty(DirectDomProtoViewRef, "parameters", {get: function() { - return [[RenderProtoView]]; - }}); - DirectDomViewRef = (function($__super) { - function DirectDomViewRef(delegate) { - assert.argumentTypes(delegate, RenderView); - $traceurRuntime.superConstructor(DirectDomViewRef).call(this); - this.delegate = delegate; - } - return ($traceurRuntime.createClass)(DirectDomViewRef, {}, {}, $__super); - }(api.RenderViewRef)); - $__export("DirectDomViewRef", DirectDomViewRef); - Object.defineProperty(DirectDomViewRef, "parameters", {get: function() { - return [[RenderView]]; - }}); - DirectDomRenderer = (function($__super) { - function DirectDomRenderer(compiler, viewFactory, viewHydrator, shadowDomStrategy) { - assert.argumentTypes(compiler, Compiler, viewFactory, ViewFactory, viewHydrator, RenderViewHydrator, shadowDomStrategy, ShadowDomStrategy); - $traceurRuntime.superConstructor(DirectDomRenderer).call(this); - this._compiler = compiler; - this._viewFactory = viewFactory; - this._viewHydrator = viewHydrator; - this._shadowDomStrategy = shadowDomStrategy; + __esModule = true; + $__export("__esModule", __esModule); + DynamicProtoChangeDetector = (function($__super) { + function DynamicProtoChangeDetector(_pipeRegistry, _bindingRecords, _variableBindings, _directiveRecords, _changeControlStrategy) { + $traceurRuntime.superConstructor(DynamicProtoChangeDetector).call(this); + this._pipeRegistry = _pipeRegistry; + this._bindingRecords = _bindingRecords; + this._variableBindings = _variableBindings; + this._directiveRecords = _directiveRecords; + this._changeControlStrategy = _changeControlStrategy; + } + return ($traceurRuntime.createClass)(DynamicProtoChangeDetector, { + instantiate: function(dispatcher) { + this._createRecordsIfNecessary(); + return new DynamicChangeDetector(this._changeControlStrategy, dispatcher, this._pipeRegistry, this._records, this._directiveRecords); + }, + _createRecordsIfNecessary: function() { + var $__0 = this; + if (isBlank(this._records)) { + var recordBuilder = new ProtoRecordBuilder(); + ListWrapper.forEach(this._bindingRecords, (function(b) { + recordBuilder.addAst(b, $__0._variableBindings); + })); + this._records = coalesce(recordBuilder.records); + } + } + }, {}, $__super); + }(ProtoChangeDetector)); + $__export("DynamicProtoChangeDetector", DynamicProtoChangeDetector); + _jitProtoChangeDetectorClassCounter = 0; + JitProtoChangeDetector = (function($__super) { + function JitProtoChangeDetector(_pipeRegistry, _bindingRecords, _variableBindings, _directiveRecords, _changeControlStrategy) { + $traceurRuntime.superConstructor(JitProtoChangeDetector).call(this); + this._pipeRegistry = _pipeRegistry; + this._bindingRecords = _bindingRecords; + this._variableBindings = _variableBindings; + this._directiveRecords = _directiveRecords; + this._changeControlStrategy = _changeControlStrategy; + this._factory = null; } - return ($traceurRuntime.createClass)(DirectDomRenderer, { - createHostProtoView: function(directiveMetadata) { - assert.argumentTypes(directiveMetadata, api.DirectiveMetadata); - return assert.returnType((this._compiler.compileHost(directiveMetadata)), assert.genericType(Promise, api.ProtoViewDto)); - }, - createImperativeComponentProtoView: function(rendererId) { - var protoViewBuilder = new ProtoViewBuilder(null); - protoViewBuilder.setImperativeRendererId(rendererId); - return assert.returnType((PromiseWrapper.resolve(protoViewBuilder.build())), assert.genericType(Promise, api.ProtoViewDto)); - }, - compile: function(view) { - assert.argumentTypes(view, api.ViewDefinition); - return assert.returnType((this._compiler.compile(view)), assert.genericType(Promise, api.ProtoViewDto)); - }, - mergeChildComponentProtoViews: function(protoViewRef, protoViewRefs) { - assert.argumentTypes(protoViewRef, api.RenderProtoViewRef, protoViewRefs, assert.genericType(List, api.RenderProtoViewRef)); - _resolveProtoView(protoViewRef).mergeChildComponentProtoViews(ListWrapper.map(protoViewRefs, _resolveProtoView)); - }, - createViewInContainer: function(vcRef, atIndex, protoViewRef) { - assert.argumentTypes(vcRef, api.RenderViewContainerRef, atIndex, assert.type.number, protoViewRef, api.RenderProtoViewRef); - var view = this._viewFactory.getView(_resolveProtoView(protoViewRef)); - var vc = _resolveViewContainer(vcRef); - this._viewHydrator.hydrateViewInViewContainer(vc, view); - vc.insert(view, atIndex); - return assert.returnType((_collectComponentChildViewRefs(view)), assert.genericType(List, api.RenderViewRef)); - }, - destroyViewInContainer: function(vcRef, atIndex) { - assert.argumentTypes(vcRef, api.RenderViewContainerRef, atIndex, assert.type.number); - var vc = _resolveViewContainer(vcRef); - var view = vc.detach(atIndex); - this._viewHydrator.dehydrateViewInViewContainer(vc, view); - this._viewFactory.returnView(view); - }, - insertViewIntoContainer: function(vcRef) { - var atIndex = arguments[1] !== (void 0) ? arguments[1] : -1; - var viewRef = arguments[2]; - assert.argumentTypes(vcRef, api.RenderViewContainerRef, atIndex, assert.type.any, viewRef, api.RenderViewRef); - _resolveViewContainer(vcRef).insert(_resolveView(viewRef), atIndex); - }, - detachViewFromContainer: function(vcRef, atIndex) { - assert.argumentTypes(vcRef, api.RenderViewContainerRef, atIndex, assert.type.number); - _resolveViewContainer(vcRef).detach(atIndex); - }, - createDynamicComponentView: function(hostViewRef, elementIndex, componentViewRef) { - assert.argumentTypes(hostViewRef, api.RenderViewRef, elementIndex, assert.type.number, componentViewRef, api.RenderProtoViewRef); - var hostView = _resolveView(hostViewRef); - var componentView = this._viewFactory.getView(_resolveProtoView(componentViewRef)); - this._viewHydrator.hydrateDynamicComponentView(hostView, elementIndex, componentView); - return assert.returnType((_collectComponentChildViewRefs(componentView)), assert.genericType(List, api.RenderViewRef)); - }, - destroyDynamicComponentView: function(hostViewRef, elementIndex) { - assert.argumentTypes(hostViewRef, api.RenderViewRef, elementIndex, assert.type.number); - throw new BaseException('Not supported yet'); - }, - createInPlaceHostView: function(parentViewRef, hostElementSelector, hostProtoViewRef) { - assert.argumentTypes(parentViewRef, api.RenderViewRef, hostElementSelector, assert.type.any, hostProtoViewRef, api.RenderProtoViewRef); - var parentView = _resolveView(parentViewRef); - var hostView = this._viewFactory.createInPlaceHostView(hostElementSelector, _resolveProtoView(hostProtoViewRef)); - this._viewHydrator.hydrateInPlaceHostView(parentView, hostView); - return assert.returnType((_collectComponentChildViewRefs(hostView)), assert.genericType(List, api.RenderViewRef)); - }, - destroyInPlaceHostView: function(parentViewRef, hostViewRef) { - assert.argumentTypes(parentViewRef, api.RenderViewRef, hostViewRef, api.RenderViewRef); - var parentView = _resolveView(parentViewRef); - var hostView = _resolveView(hostViewRef); - this._viewHydrator.dehydrateInPlaceHostView(parentView, hostView); - }, - setImperativeComponentRootNodes: function(parentViewRef, elementIndex, nodes) { - assert.argumentTypes(parentViewRef, api.RenderViewRef, elementIndex, assert.type.number, nodes, List); - var parentView = _resolveView(parentViewRef); - var hostElement = parentView.boundElements[elementIndex]; - var componentView = parentView.componentChildViews[elementIndex]; - if (isBlank(componentView)) { - throw new BaseException(("There is no componentChildView at index " + elementIndex)); - } - if (isBlank(componentView.proto.imperativeRendererId)) { - throw new BaseException("This component view has no imperative renderer"); - } - ViewContainer.removeViewNodes(componentView); - componentView.rootNodes = nodes; - this._shadowDomStrategy.attachTemplate(hostElement, componentView); + return ($traceurRuntime.createClass)(JitProtoChangeDetector, { + instantiate: function(dispatcher) { + this._createFactoryIfNecessary(); + return this._factory(dispatcher, this._pipeRegistry); }, - setElementProperty: function(viewRef, elementIndex, propertyName, propertyValue) { - assert.argumentTypes(viewRef, api.RenderViewRef, elementIndex, assert.type.number, propertyName, assert.type.string, propertyValue, assert.type.any); - _resolveView(viewRef).setElementProperty(elementIndex, propertyName, propertyValue); + _createFactoryIfNecessary: function() { + var $__0 = this; + if (isBlank(this._factory)) { + var recordBuilder = new ProtoRecordBuilder(); + ListWrapper.forEach(this._bindingRecords, (function(b) { + recordBuilder.addAst(b, $__0._variableBindings); + })); + var c = _jitProtoChangeDetectorClassCounter++; + var records = coalesce(recordBuilder.records); + var typeName = ("ChangeDetector" + c); + this._factory = new ChangeDetectorJITGenerator(typeName, this._changeControlStrategy, records, this._directiveRecords).generate(); + } + } + }, {}, $__super); + }(ProtoChangeDetector)); + $__export("JitProtoChangeDetector", JitProtoChangeDetector); + ProtoRecordBuilder = (function() { + function ProtoRecordBuilder() { + this.records = []; + } + return ($traceurRuntime.createClass)(ProtoRecordBuilder, {addAst: function(b) { + var variableBindings = arguments[1] !== (void 0) ? arguments[1] : null; + var last = ListWrapper.last(this.records); + if (isPresent(last) && last.bindingRecord.directiveRecord == b.directiveRecord) { + last.lastInDirective = false; + } + var pr = _ConvertAstIntoProtoRecords.convert(b, this.records.length, variableBindings); + if (!ListWrapper.isEmpty(pr)) { + var last = ListWrapper.last(pr); + last.lastInBinding = true; + last.lastInDirective = true; + this.records = ListWrapper.concat(this.records, pr); + } + }}, {}); + }()); + _ConvertAstIntoProtoRecords = (function() { + function _ConvertAstIntoProtoRecords(bindingRecord, contextIndex, expressionAsString, variableBindings) { + this.bindingRecord = bindingRecord; + this.contextIndex = contextIndex; + this.expressionAsString = expressionAsString; + this.variableBindings = variableBindings; + this.protoRecords = []; + } + return ($traceurRuntime.createClass)(_ConvertAstIntoProtoRecords, { + visitImplicitReceiver: function(ast) { + return this.bindingRecord.implicitReceiver; }, - setText: function(viewRef, textNodeIndex, text) { - assert.argumentTypes(viewRef, api.RenderViewRef, textNodeIndex, assert.type.number, text, assert.type.string); - _resolveView(viewRef).setText(textNodeIndex, text); + visitInterpolation: function(ast) { + var args = this._visitAll(ast.expressions); + return this._addRecord(RECORD_TYPE_INTERPOLATE, "interpolate", _interpolationFn(ast.strings), args, ast.strings, 0); }, - setEventDispatcher: function(viewRef, dispatcher) { - assert.argumentTypes(viewRef, api.RenderViewRef, dispatcher, assert.type.any); - _resolveView(viewRef).setEventDispatcher(dispatcher); + visitLiteralPrimitive: function(ast) { + return this._addRecord(RECORD_TYPE_CONST, "literal", ast.value, [], null, 0); + }, + visitAccessMember: function(ast) { + var receiver = ast.receiver.visit(this); + if (isPresent(this.variableBindings) && ListWrapper.contains(this.variableBindings, ast.name) && ast.receiver instanceof ImplicitReceiver) { + return this._addRecord(RECORD_TYPE_LOCAL, ast.name, ast.name, [], null, receiver); + } else { + return this._addRecord(RECORD_TYPE_PROPERTY, ast.name, ast.getter, [], null, receiver); + } + }, + visitMethodCall: function(ast) { + ; + var receiver = ast.receiver.visit(this); + var args = this._visitAll(ast.args); + if (isPresent(this.variableBindings) && ListWrapper.contains(this.variableBindings, ast.name)) { + var target = this._addRecord(RECORD_TYPE_LOCAL, ast.name, ast.name, [], null, receiver); + return this._addRecord(RECORD_TYPE_INVOKE_CLOSURE, "closure", null, args, null, target); + } else { + return this._addRecord(RECORD_TYPE_INVOKE_METHOD, ast.name, ast.fn, args, null, receiver); + } + }, + visitFunctionCall: function(ast) { + var target = ast.target.visit(this); + var args = this._visitAll(ast.args); + return this._addRecord(RECORD_TYPE_INVOKE_CLOSURE, "closure", null, args, null, target); + }, + visitLiteralArray: function(ast) { + var primitiveName = ("arrayFn" + ast.expressions.length); + return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, primitiveName, _arrayFn(ast.expressions.length), this._visitAll(ast.expressions), null, 0); + }, + visitLiteralMap: function(ast) { + return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, _mapPrimitiveName(ast.keys), ChangeDetectionUtil.mapFn(ast.keys), this._visitAll(ast.values), null, 0); + }, + visitBinary: function(ast) { + var left = ast.left.visit(this); + var right = ast.right.visit(this); + return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, _operationToPrimitiveName(ast.operation), _operationToFunction(ast.operation), [left, right], null, 0); + }, + visitPrefixNot: function(ast) { + var exp = ast.expression.visit(this); + return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, "operation_negate", ChangeDetectionUtil.operation_negate, [exp], null, 0); + }, + visitConditional: function(ast) { + var c = ast.condition.visit(this); + var t = ast.trueExp.visit(this); + var f = ast.falseExp.visit(this); + return this._addRecord(RECORD_TYPE_PRIMITIVE_OP, "cond", ChangeDetectionUtil.cond, [c, t, f], null, 0); + }, + visitPipe: function(ast) { + var value = ast.exp.visit(this); + var type = ast.inBinding ? RECORD_TYPE_BINDING_PIPE : RECORD_TYPE_PIPE; + return this._addRecord(type, ast.name, ast.name, [], null, value); + }, + visitKeyedAccess: function(ast) { + var obj = ast.obj.visit(this); + var key = ast.key.visit(this); + return this._addRecord(RECORD_TYPE_KEYED_ACCESS, "keyedAccess", ChangeDetectionUtil.keyedAccess, [key], null, obj); + }, + _visitAll: function(asts) { + var res = ListWrapper.createFixedSize(asts.length); + for (var i = 0; i < asts.length; ++i) { + res[i] = asts[i].visit(this); + } + return res; + }, + _addRecord: function(type, name, funcOrValue, args, fixedArgs, context) { + var selfIndex = ++this.contextIndex; + if (context instanceof DirectiveIndex) { + ListWrapper.push(this.protoRecords, new ProtoRecord(type, name, funcOrValue, args, fixedArgs, -1, context, selfIndex, this.bindingRecord, this.expressionAsString, false, false)); + } else { + ListWrapper.push(this.protoRecords, new ProtoRecord(type, name, funcOrValue, args, fixedArgs, context, null, selfIndex, this.bindingRecord, this.expressionAsString, false, false)); + } + return selfIndex; } - }, {}, $__super); - }(api.Renderer)); - $__export("DirectDomRenderer", DirectDomRenderer); - Object.defineProperty(DirectDomRenderer, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(DirectDomRenderer, "parameters", {get: function() { - return [[Compiler], [ViewFactory], [RenderViewHydrator], [ShadowDomStrategy]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.createHostProtoView, "parameters", {get: function() { - return [[api.DirectiveMetadata]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.compile, "parameters", {get: function() { - return [[api.ViewDefinition]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.mergeChildComponentProtoViews, "parameters", {get: function() { - return [[api.RenderProtoViewRef], [assert.genericType(List, api.RenderProtoViewRef)]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.createViewInContainer, "parameters", {get: function() { - return [[api.RenderViewContainerRef], [assert.type.number], [api.RenderProtoViewRef]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.destroyViewInContainer, "parameters", {get: function() { - return [[api.RenderViewContainerRef], [assert.type.number]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.insertViewIntoContainer, "parameters", {get: function() { - return [[api.RenderViewContainerRef], [], [api.RenderViewRef]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.detachViewFromContainer, "parameters", {get: function() { - return [[api.RenderViewContainerRef], [assert.type.number]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.createDynamicComponentView, "parameters", {get: function() { - return [[api.RenderViewRef], [assert.type.number], [api.RenderProtoViewRef]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.destroyDynamicComponentView, "parameters", {get: function() { - return [[api.RenderViewRef], [assert.type.number]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.createInPlaceHostView, "parameters", {get: function() { - return [[api.RenderViewRef], [], [api.RenderProtoViewRef]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.destroyInPlaceHostView, "parameters", {get: function() { - return [[api.RenderViewRef], [api.RenderViewRef]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.setImperativeComponentRootNodes, "parameters", {get: function() { - return [[api.RenderViewRef], [assert.type.number], [List]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.setElementProperty, "parameters", {get: function() { - return [[api.RenderViewRef], [assert.type.number], [assert.type.string], [assert.type.any]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.setText, "parameters", {get: function() { - return [[api.RenderViewRef], [assert.type.number], [assert.type.string]]; - }}); - Object.defineProperty(DirectDomRenderer.prototype.setEventDispatcher, "parameters", {get: function() { - return [[api.RenderViewRef], [assert.type.any]]; - }}); + }, {convert: function(b, contextIndex, variableBindings) { + var c = new _ConvertAstIntoProtoRecords(b, contextIndex, b.ast.toString(), variableBindings); + b.ast.visit(c); + return c.protoRecords; + }}); + }()); } }; }); -System.register("angular2/src/change_detection/parser/lexer", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/collection", "angular2/src/facade/lang"], function($__export) { +System.register("angular2/src/change_detection/change_detection", ["angular2/src/change_detection/proto_change_detector", "angular2/src/change_detection/pipes/pipe_registry", "angular2/src/change_detection/pipes/iterable_changes", "angular2/src/change_detection/pipes/keyvalue_changes", "angular2/src/change_detection/pipes/observable_pipe", "angular2/src/change_detection/pipes/promise_pipe", "angular2/src/change_detection/pipes/null_pipe", "angular2/src/change_detection/constants", "angular2/src/change_detection/interfaces", "angular2/src/di/decorators"], function($__export) { "use strict"; - var __moduleName = "angular2/src/change_detection/parser/lexer"; - var assert, + var __moduleName = "angular2/src/change_detection/change_detection"; + var __decorate, + __metadata, + DynamicProtoChangeDetector, + JitProtoChangeDetector, + PipeRegistry, + IterableChangesFactory, + KeyValueChangesFactory, + ObservablePipeFactory, + PromisePipeFactory, + NullPipeFactory, + DEFAULT, + ChangeDetection, Injectable, - List, - ListWrapper, - SetWrapper, - int, - NumberWrapper, - StringJoiner, - StringWrapper, - TOKEN_TYPE_CHARACTER, - TOKEN_TYPE_IDENTIFIER, - TOKEN_TYPE_KEYWORD, - TOKEN_TYPE_STRING, - TOKEN_TYPE_OPERATOR, - TOKEN_TYPE_NUMBER, - Lexer, - Token, - EOF, - $EOF, - $TAB, - $LF, - $VTAB, - $FF, - $CR, - $SPACE, - $BANG, - $DQ, - $HASH, - $$, - $PERCENT, - $AMPERSAND, - $SQ, - $LPAREN, - $RPAREN, - $STAR, - $PLUS, - $COMMA, - $MINUS, - $PERIOD, - $SLASH, - $COLON, - $SEMICOLON, - $LT, - $EQ, - $GT, - $QUESTION, - $0, - $9, - $A, - $E, - $Z, - $LBRACKET, - $BACKSLASH, - $RBRACKET, - $CARET, - $_, - $a, - $e, - $f, - $n, - $r, - $t, - $u, - $v, - $z, - $LBRACE, - $BAR, - $RBRACE, - $NBSP, - ScannerError, - _Scanner, - OPERATORS, - KEYWORDS; - function newCharacterToken(index, code) { - assert.argumentTypes(index, int, code, int); - return assert.returnType((new Token(index, TOKEN_TYPE_CHARACTER, code, StringWrapper.fromCharCode(code))), Token); - } - function newIdentifierToken(index, text) { - assert.argumentTypes(index, int, text, assert.type.string); - return assert.returnType((new Token(index, TOKEN_TYPE_IDENTIFIER, 0, text)), Token); - } - function newKeywordToken(index, text) { - assert.argumentTypes(index, int, text, assert.type.string); - return assert.returnType((new Token(index, TOKEN_TYPE_KEYWORD, 0, text)), Token); - } - function newOperatorToken(index, text) { - assert.argumentTypes(index, int, text, assert.type.string); - return assert.returnType((new Token(index, TOKEN_TYPE_OPERATOR, 0, text)), Token); - } - function newStringToken(index, text) { - assert.argumentTypes(index, int, text, assert.type.string); - return assert.returnType((new Token(index, TOKEN_TYPE_STRING, 0, text)), Token); - } - function newNumberToken(index, n) { - assert.argumentTypes(index, int, n, assert.type.number); - return assert.returnType((new Token(index, TOKEN_TYPE_NUMBER, n, "")), Token); - } - function isWhitespace(code) { - assert.argumentTypes(code, int); - return assert.returnType(((code >= $TAB && code <= $SPACE) || (code == $NBSP)), assert.type.boolean); - } - function isIdentifierStart(code) { - assert.argumentTypes(code, int); - return assert.returnType((($a <= code && code <= $z) || ($A <= code && code <= $Z) || (code == $_) || (code == $$)), assert.type.boolean); - } - function isIdentifierPart(code) { - assert.argumentTypes(code, int); - return assert.returnType((($a <= code && code <= $z) || ($A <= code && code <= $Z) || ($0 <= code && code <= $9) || (code == $_) || (code == $$)), assert.type.boolean); - } - function isDigit(code) { - assert.argumentTypes(code, int); - return assert.returnType(($0 <= code && code <= $9), assert.type.boolean); + __esModule, + keyValDiff, + iterableDiff, + async, + defaultPipes, + DynamicChangeDetection, + JitChangeDetection, + defaultPipeRegistry; + return { + setters: [function($__m) { + DynamicProtoChangeDetector = $__m.DynamicProtoChangeDetector; + JitProtoChangeDetector = $__m.JitProtoChangeDetector; + }, function($__m) { + PipeRegistry = $__m.PipeRegistry; + }, function($__m) { + IterableChangesFactory = $__m.IterableChangesFactory; + }, function($__m) { + KeyValueChangesFactory = $__m.KeyValueChangesFactory; + }, function($__m) { + ObservablePipeFactory = $__m.ObservablePipeFactory; + }, function($__m) { + PromisePipeFactory = $__m.PromisePipeFactory; + }, function($__m) { + NullPipeFactory = $__m.NullPipeFactory; + }, function($__m) { + DEFAULT = $__m.DEFAULT; + }, function($__m) { + ChangeDetection = $__m.ChangeDetection; + }, function($__m) { + Injectable = $__m.Injectable; + }], + execute: function() { + __decorate = (this && this.__decorate) || function(decorators, target, key, desc) { + if (typeof Reflect === "object" && typeof Reflect.decorate === "function") + return Reflect.decorate(decorators, target, key, desc); + switch (arguments.length) { + case 2: + return decorators.reduceRight(function(o, d) { + return (d && d(o)) || o; + }, target); + case 3: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key)), void 0; + }, void 0); + case 4: + return decorators.reduceRight(function(o, d) { + return (d && d(target, key, o)) || o; + }, desc); + } + }; + __metadata = (this && this.__metadata) || function(k, v) { + if (typeof Reflect === "object" && typeof Reflect.metadata === "function") + return Reflect.metadata(k, v); + }; + __esModule = true; + $__export("__esModule", __esModule); + keyValDiff = [new KeyValueChangesFactory(), new NullPipeFactory()]; + $__export("keyValDiff", keyValDiff); + iterableDiff = [new IterableChangesFactory(), new NullPipeFactory()]; + $__export("iterableDiff", iterableDiff); + async = [new ObservablePipeFactory(), new PromisePipeFactory(), new NullPipeFactory()]; + $__export("async", async); + defaultPipes = { + "iterableDiff": iterableDiff, + "keyValDiff": keyValDiff, + "async": async + }; + $__export("defaultPipes", defaultPipes); + DynamicChangeDetection = (function($__super) { + function $__0(registry) { + $traceurRuntime.superConstructor($__0).call(this); + this.registry = registry; + } + return ($traceurRuntime.createClass)($__0, {createProtoChangeDetector: function(name, bindingRecords, variableBindings, directiveRecords) { + var changeControlStrategy = arguments[4] !== (void 0) ? arguments[4] : DEFAULT; + return new DynamicProtoChangeDetector(this.registry, bindingRecords, variableBindings, directiveRecords, changeControlStrategy); + }}, {}, $__super); + }(ChangeDetection)); + $__export("DynamicChangeDetection", DynamicChangeDetection); + $__export("DynamicChangeDetection", DynamicChangeDetection = __decorate([Injectable(), __metadata('design:paramtypes', [PipeRegistry])], DynamicChangeDetection)); + JitChangeDetection = (function($__super) { + function $__0(registry) { + $traceurRuntime.superConstructor($__0).call(this); + this.registry = registry; + } + return ($traceurRuntime.createClass)($__0, {createProtoChangeDetector: function(name, bindingRecords, variableBindings, directiveRecords) { + var changeControlStrategy = arguments[4] !== (void 0) ? arguments[4] : DEFAULT; + return new JitProtoChangeDetector(this.registry, bindingRecords, variableBindings, directiveRecords, changeControlStrategy); + }}, {}, $__super); + }(ChangeDetection)); + $__export("JitChangeDetection", JitChangeDetection); + $__export("JitChangeDetection", JitChangeDetection = __decorate([Injectable(), __metadata('design:paramtypes', [PipeRegistry])], JitChangeDetection)); + defaultPipeRegistry = new PipeRegistry(defaultPipes); + $__export("defaultPipeRegistry", defaultPipeRegistry); + } + }; +}); + +System.register("angular2/src/di/injector", ["angular2/src/facade/collection", "angular2/src/di/binding", "angular2/src/di/exceptions", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/di/key"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/di/injector"; + var List, + MapWrapper, + ListWrapper, + ResolvedBinding, + Binding, + BindingBuilder, + bind, + AbstractBindingError, + NoBindingError, + AsyncBindingError, + CyclicDependencyError, + InstantiationError, + InvalidBindingError, + FunctionWrapper, + Type, + isPresent, + isBlank, + PromiseWrapper, + Key, + _constructing, + _notFound, + _Waiting, + Injector, + _SyncInjectorStrategy, + _AsyncInjectorStrategy; + function _isWaiting(obj) { + return obj instanceof _Waiting; } - function isExponentStart(code) { - assert.argumentTypes(code, int); - return assert.returnType((code == $e || code == $E), assert.type.boolean); + function _resolveBindings(bindings) { + var resolvedList = ListWrapper.createFixedSize(bindings.length); + for (var i = 0; i < bindings.length; i++) { + var unresolved = bindings[i]; + var resolved = void 0; + if (unresolved instanceof ResolvedBinding) { + resolved = unresolved; + } else if (unresolved instanceof Type) { + resolved = bind(unresolved).toClass(unresolved).resolve(); + } else if (unresolved instanceof Binding) { + resolved = unresolved.resolve(); + } else if (unresolved instanceof List) { + resolved = _resolveBindings(unresolved); + } else if (unresolved instanceof BindingBuilder) { + throw new InvalidBindingError(unresolved.token); + } else { + throw new InvalidBindingError(unresolved); + } + resolvedList[i] = resolved; + } + return resolvedList; } - function isExponentSign(code) { - assert.argumentTypes(code, int); - return assert.returnType((code == $MINUS || code == $PLUS), assert.type.boolean); + function _createListOfBindings(flattenedBindings) { + var bindings = ListWrapper.createFixedSize(Key.numberOfKeys + 1); + MapWrapper.forEach(flattenedBindings, (function(v, keyId) { + return bindings[keyId] = v; + })); + return bindings; } - function unescape(code) { - assert.argumentTypes(code, int); - switch (code) { - case $n: - return assert.returnType(($LF), int); - case $f: - return assert.returnType(($FF), int); - case $r: - return assert.returnType(($CR), int); - case $t: - return assert.returnType(($TAB), int); - case $v: - return assert.returnType(($VTAB), int); - default: - return assert.returnType((code), int); - } + function _flattenBindings(bindings, res) { + ListWrapper.forEach(bindings, function(b) { + if (b instanceof ResolvedBinding) { + MapWrapper.set(res, b.key.id, b); + } else if (b instanceof List) { + _flattenBindings(b, res); + } + }); + return res; } return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { - Injectable = $__m.Injectable; - }, function($__m) { List = $__m.List; + MapWrapper = $__m.MapWrapper; ListWrapper = $__m.ListWrapper; - SetWrapper = $__m.SetWrapper; }, function($__m) { - int = $__m.int; - NumberWrapper = $__m.NumberWrapper; - StringJoiner = $__m.StringJoiner; - StringWrapper = $__m.StringWrapper; + ResolvedBinding = $__m.ResolvedBinding; + Binding = $__m.Binding; + BindingBuilder = $__m.BindingBuilder; + bind = $__m.bind; + }, function($__m) { + AbstractBindingError = $__m.AbstractBindingError; + NoBindingError = $__m.NoBindingError; + AsyncBindingError = $__m.AsyncBindingError; + CyclicDependencyError = $__m.CyclicDependencyError; + InstantiationError = $__m.InstantiationError; + InvalidBindingError = $__m.InvalidBindingError; + }, function($__m) { + FunctionWrapper = $__m.FunctionWrapper; + Type = $__m.Type; + isPresent = $__m.isPresent; + isBlank = $__m.isBlank; + }, function($__m) { + PromiseWrapper = $__m.PromiseWrapper; + }, function($__m) { + Key = $__m.Key; }], execute: function() { - TOKEN_TYPE_CHARACTER = 1; - $__export("TOKEN_TYPE_CHARACTER", TOKEN_TYPE_CHARACTER); - TOKEN_TYPE_IDENTIFIER = 2; - $__export("TOKEN_TYPE_IDENTIFIER", TOKEN_TYPE_IDENTIFIER); - TOKEN_TYPE_KEYWORD = 3; - $__export("TOKEN_TYPE_KEYWORD", TOKEN_TYPE_KEYWORD); - TOKEN_TYPE_STRING = 4; - $__export("TOKEN_TYPE_STRING", TOKEN_TYPE_STRING); - TOKEN_TYPE_OPERATOR = 5; - $__export("TOKEN_TYPE_OPERATOR", TOKEN_TYPE_OPERATOR); - TOKEN_TYPE_NUMBER = 6; - $__export("TOKEN_TYPE_NUMBER", TOKEN_TYPE_NUMBER); - Lexer = (function() { - function Lexer() {} - return ($traceurRuntime.createClass)(Lexer, {tokenize: function(text) { - assert.argumentTypes(text, assert.type.string); - var scanner = new _Scanner(text); - var tokens = []; - var token = scanner.scanToken(); - while (token != null) { - ListWrapper.push(tokens, token); - token = scanner.scanToken(); - } - return assert.returnType((tokens), List); - }}, {}); + _constructing = new Object(); + _notFound = new Object(); + _Waiting = (function() { + function _Waiting(promise) { + this.promise = promise; + } + return ($traceurRuntime.createClass)(_Waiting, {}, {}); }()); - $__export("Lexer", Lexer); - Object.defineProperty(Lexer, "annotations", {get: function() { - return [new Injectable()]; - }}); - Object.defineProperty(Lexer.prototype.tokenize, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Token = (function() { - function Token(index, type, numValue, strValue) { - assert.argumentTypes(index, int, type, int, numValue, assert.type.number, strValue, assert.type.string); - this.index = index; - this.type = type; - this._numValue = numValue; - this._strValue = strValue; + Injector = (function() { + function Injector(bindings, parent, defaultBindings) { + this._bindings = bindings; + this._instances = this._createInstances(); + this._parent = parent; + this._defaultBindings = defaultBindings; + this._asyncStrategy = new _AsyncInjectorStrategy(this); + this._syncStrategy = new _SyncInjectorStrategy(this); } - return ($traceurRuntime.createClass)(Token, { - isCharacter: function(code) { - assert.argumentTypes(code, int); - return assert.returnType(((this.type == TOKEN_TYPE_CHARACTER && this._numValue == code)), assert.type.boolean); + return ($traceurRuntime.createClass)(Injector, { + get parent() { + return this._parent; }, - isNumber: function() { - return assert.returnType(((this.type == TOKEN_TYPE_NUMBER)), assert.type.boolean); + get: function(token) { + return this._getByKey(Key.get(token), false, false, false); }, - isString: function() { - return assert.returnType(((this.type == TOKEN_TYPE_STRING)), assert.type.boolean); + getOptional: function(token) { + return this._getByKey(Key.get(token), false, false, true); }, - isOperator: function(operater) { - assert.argumentTypes(operater, assert.type.string); - return assert.returnType(((this.type == TOKEN_TYPE_OPERATOR && this._strValue == operater)), assert.type.boolean); + asyncGet: function(token) { + return this._getByKey(Key.get(token), true, false, false); }, - isIdentifier: function() { - return assert.returnType(((this.type == TOKEN_TYPE_IDENTIFIER)), assert.type.boolean); + resolveAndCreateChild: function(bindings) { + return new Injector(Injector.resolve(bindings), this, false); }, - isKeyword: function() { - return assert.returnType(((this.type == TOKEN_TYPE_KEYWORD)), assert.type.boolean); + createChildFromResolved: function(bindings) { + return new Injector(bindings, this, false); }, - isKeywordVar: function() { - return assert.returnType(((this.type == TOKEN_TYPE_KEYWORD && this._strValue == "var")), assert.type.boolean); + _createInstances: function() { + return ListWrapper.createFixedSize(Key.numberOfKeys + 1); }, - isKeywordNull: function() { - return assert.returnType(((this.type == TOKEN_TYPE_KEYWORD && this._strValue == "null")), assert.type.boolean); + _getByKey: function(key, returnPromise, returnLazy, optional) { + var $__0 = this; + if (returnLazy) { + return (function() { + return $__0._getByKey(key, returnPromise, false, optional); + }); + } + var strategy = returnPromise ? this._asyncStrategy : this._syncStrategy; + var instance = strategy.readFromCache(key); + if (instance !== _notFound) + return instance; + instance = strategy.instantiate(key); + if (instance !== _notFound) + return instance; + if (isPresent(this._parent)) { + return this._parent._getByKey(key, returnPromise, returnLazy, optional); + } + if (optional) { + return null; + } else { + throw new NoBindingError(key); + } + }, + _resolveDependencies: function(key, binding, forceAsync) { + var $__0 = this; + try { + var getDependency = (function(d) { + return $__0._getByKey(d.key, forceAsync || d.asPromise, d.lazy, d.optional); + }); + return ListWrapper.map(binding.dependencies, getDependency); + } catch (e) { + this._clear(key); + if (e instanceof AbstractBindingError) + e.addKey(key); + throw e; + } + }, + _getInstance: function(key) { + if (this._instances.length <= key.id) + return null; + return ListWrapper.get(this._instances, key.id); + }, + _setInstance: function(key, obj) { + ListWrapper.set(this._instances, key.id, obj); }, - isKeywordUndefined: function() { - return assert.returnType(((this.type == TOKEN_TYPE_KEYWORD && this._strValue == "undefined")), assert.type.boolean); + _getBinding: function(key) { + var binding = this._bindings.length <= key.id ? null : ListWrapper.get(this._bindings, key.id); + if (isBlank(binding) && this._defaultBindings) { + var token = key.token; + return bind(key.token).toClass(token).resolve(); + } else { + return binding; + } }, - isKeywordTrue: function() { - return assert.returnType(((this.type == TOKEN_TYPE_KEYWORD && this._strValue == "true")), assert.type.boolean); + _markAsConstructing: function(key) { + this._setInstance(key, _constructing); }, - isKeywordFalse: function() { - return assert.returnType(((this.type == TOKEN_TYPE_KEYWORD && this._strValue == "false")), assert.type.boolean); + _clear: function(key) { + this._setInstance(key, null); + } + }, { + resolve: function(bindings) { + var resolvedBindings = _resolveBindings(bindings); + var flatten = _flattenBindings(resolvedBindings, MapWrapper.create()); + return _createListOfBindings(flatten); }, - toNumber: function() { - return assert.returnType(((this.type == TOKEN_TYPE_NUMBER) ? this._numValue : -1), assert.type.number); + resolveAndCreate: function(bindings) { + var $__3; + var $__2 = arguments[1] !== (void 0) ? arguments[1] : {}, + defaultBindings = ($__3 = $__2.defaultBindings) === void 0 ? false : $__3; + return new Injector(Injector.resolve(bindings), null, defaultBindings); }, - toString: function() { - var type = assert.type(this.type, int); - if (type >= TOKEN_TYPE_CHARACTER && type <= TOKEN_TYPE_STRING) { - return assert.returnType((this._strValue), assert.type.string); - } else if (type == TOKEN_TYPE_NUMBER) { - return assert.returnType((this._numValue.toString()), assert.type.string); - } else { - return assert.returnType((null), assert.type.string); - } + fromResolvedBindings: function(bindings) { + var $__3; + var $__2 = arguments[1] !== (void 0) ? arguments[1] : {}, + defaultBindings = ($__3 = $__2.defaultBindings) === void 0 ? false : $__3; + return new Injector(bindings, null, defaultBindings); } - }, {}); + }); }()); - $__export("Token", Token); - Object.defineProperty(Token, "parameters", {get: function() { - return [[int], [int], [assert.type.number], [assert.type.string]]; - }}); - Object.defineProperty(Token.prototype.isCharacter, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(Token.prototype.isOperator, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(newCharacterToken, "parameters", {get: function() { - return [[int], [int]]; - }}); - Object.defineProperty(newIdentifierToken, "parameters", {get: function() { - return [[int], [assert.type.string]]; - }}); - Object.defineProperty(newKeywordToken, "parameters", {get: function() { - return [[int], [assert.type.string]]; - }}); - Object.defineProperty(newOperatorToken, "parameters", {get: function() { - return [[int], [assert.type.string]]; - }}); - Object.defineProperty(newStringToken, "parameters", {get: function() { - return [[int], [assert.type.string]]; - }}); - Object.defineProperty(newNumberToken, "parameters", {get: function() { - return [[int], [assert.type.number]]; - }}); - EOF = assert.type(new Token(-1, 0, 0, ""), Token); - $__export("EOF", EOF); - $EOF = 0; - $__export("$EOF", $EOF); - $TAB = 9; - $__export("$TAB", $TAB); - $LF = 10; - $__export("$LF", $LF); - $VTAB = 11; - $__export("$VTAB", $VTAB); - $FF = 12; - $__export("$FF", $FF); - $CR = 13; - $__export("$CR", $CR); - $SPACE = 32; - $__export("$SPACE", $SPACE); - $BANG = 33; - $__export("$BANG", $BANG); - $DQ = 34; - $__export("$DQ", $DQ); - $HASH = 35; - $__export("$HASH", $HASH); - $$ = 36; - $__export("$$", $$); - $PERCENT = 37; - $__export("$PERCENT", $PERCENT); - $AMPERSAND = 38; - $__export("$AMPERSAND", $AMPERSAND); - $SQ = 39; - $__export("$SQ", $SQ); - $LPAREN = 40; - $__export("$LPAREN", $LPAREN); - $RPAREN = 41; - $__export("$RPAREN", $RPAREN); - $STAR = 42; - $__export("$STAR", $STAR); - $PLUS = 43; - $__export("$PLUS", $PLUS); - $COMMA = 44; - $__export("$COMMA", $COMMA); - $MINUS = 45; - $__export("$MINUS", $MINUS); - $PERIOD = 46; - $__export("$PERIOD", $PERIOD); - $SLASH = 47; - $__export("$SLASH", $SLASH); - $COLON = 58; - $__export("$COLON", $COLON); - $SEMICOLON = 59; - $__export("$SEMICOLON", $SEMICOLON); - $LT = 60; - $__export("$LT", $LT); - $EQ = 61; - $__export("$EQ", $EQ); - $GT = 62; - $__export("$GT", $GT); - $QUESTION = 63; - $__export("$QUESTION", $QUESTION); - $0 = 48; - $9 = 57; - $A = 65, $E = 69, $Z = 90; - $LBRACKET = 91; - $__export("$LBRACKET", $LBRACKET); - $BACKSLASH = 92; - $__export("$BACKSLASH", $BACKSLASH); - $RBRACKET = 93; - $__export("$RBRACKET", $RBRACKET); - $CARET = 94; - $_ = 95; - $a = 97, $e = 101, $f = 102, $n = 110, $r = 114, $t = 116, $u = 117, $v = 118, $z = 122; - $LBRACE = 123; - $__export("$LBRACE", $LBRACE); - $BAR = 124; - $__export("$BAR", $BAR); - $RBRACE = 125; - $__export("$RBRACE", $RBRACE); - $NBSP = 160; - ScannerError = (function($__super) { - function ScannerError(message) { - $traceurRuntime.superConstructor(ScannerError).call(this); - this.message = message; - } - return ($traceurRuntime.createClass)(ScannerError, {toString: function() { - return this.message; - }}, {}, $__super); - }(Error)); - $__export("ScannerError", ScannerError); - _Scanner = (function() { - function _Scanner(input) { - assert.argumentTypes(input, assert.type.string); - this.input = input; - this.length = input.length; - this.peek = 0; - this.index = -1; - this.advance(); + $__export("Injector", Injector); + _SyncInjectorStrategy = (function() { + function _SyncInjectorStrategy(injector) { + this.injector = injector; } - return ($traceurRuntime.createClass)(_Scanner, { - advance: function() { - this.peek = ++this.index >= this.length ? $EOF : StringWrapper.charCodeAt(this.input, this.index); - }, - scanToken: function() { - var input = this.input, - length = this.length, - peek = this.peek, - index = this.index; - while (peek <= $SPACE) { - if (++index >= length) { - peek = $EOF; - break; - } else { - peek = StringWrapper.charCodeAt(input, index); - } - } - this.peek = peek; - this.index = index; - if (index >= length) { - return assert.returnType((null), Token); + return ($traceurRuntime.createClass)(_SyncInjectorStrategy, { + readFromCache: function(key) { + if (key.token === Injector) { + return this.injector; } - if (isIdentifierStart(peek)) - return assert.returnType((this.scanIdentifier()), Token); - if (isDigit(peek)) - return assert.returnType((this.scanNumber(index)), Token); - var start = assert.type(index, int); - switch (peek) { - case $PERIOD: - this.advance(); - return assert.returnType((isDigit(this.peek) ? this.scanNumber(start) : newCharacterToken(start, $PERIOD)), Token); - case $LPAREN: - case $RPAREN: - case $LBRACE: - case $RBRACE: - case $LBRACKET: - case $RBRACKET: - case $COMMA: - case $COLON: - case $SEMICOLON: - return assert.returnType((this.scanCharacter(start, peek)), Token); - case $SQ: - case $DQ: - return assert.returnType((this.scanString()), Token); - case $HASH: - return assert.returnType((this.scanOperator(start, StringWrapper.fromCharCode(peek))), Token); - case $PLUS: - case $MINUS: - case $STAR: - case $SLASH: - case $PERCENT: - case $CARET: - case $QUESTION: - return assert.returnType((this.scanOperator(start, StringWrapper.fromCharCode(peek))), Token); - case $LT: - case $GT: - case $BANG: - case $EQ: - return assert.returnType((this.scanComplexOperator(start, $EQ, StringWrapper.fromCharCode(peek), '=')), Token); - case $AMPERSAND: - return assert.returnType((this.scanComplexOperator(start, $AMPERSAND, '&', '&')), Token); - case $BAR: - return assert.returnType((this.scanComplexOperator(start, $BAR, '|', '|')), Token); - case $NBSP: - while (isWhitespace(this.peek)) - this.advance(); - return assert.returnType((this.scanToken()), Token); + var instance = this.injector._getInstance(key); + if (instance === _constructing) { + throw new CyclicDependencyError(key); + } else if (isPresent(instance) && !_isWaiting(instance)) { + return instance; + } else { + return _notFound; } - this.error(("Unexpected character [" + StringWrapper.fromCharCode(peek) + "]"), 0); - return assert.returnType((null), Token); - }, - scanCharacter: function(start, code) { - assert.argumentTypes(start, int, code, int); - assert(this.peek == code); - this.advance(); - return assert.returnType((newCharacterToken(start, code)), Token); }, - scanOperator: function(start, str) { - assert.argumentTypes(start, int, str, assert.type.string); - assert(this.peek == StringWrapper.charCodeAt(str, 0)); - assert(SetWrapper.has(OPERATORS, str)); - this.advance(); - return assert.returnType((newOperatorToken(start, str)), Token); + instantiate: function(key) { + var binding = this.injector._getBinding(key); + if (isBlank(binding)) + return _notFound; + if (binding.providedAsPromise) + throw new AsyncBindingError(key); + this.injector._markAsConstructing(key); + var deps = this.injector._resolveDependencies(key, binding, false); + return this._createInstance(key, binding, deps); }, - scanComplexOperator: function(start, code, one, two) { - assert.argumentTypes(start, int, code, int, one, assert.type.string, two, assert.type.string); - assert(this.peek == StringWrapper.charCodeAt(one, 0)); - this.advance(); - var str = assert.type(one, assert.type.string); - while (this.peek == code) { - this.advance(); - str += two; + _createInstance: function(key, binding, deps) { + try { + var instance = FunctionWrapper.apply(binding.factory, deps); + this.injector._setInstance(key, instance); + return instance; + } catch (e) { + this.injector._clear(key); + throw new InstantiationError(e, key); } - assert(SetWrapper.has(OPERATORS, str)); - return assert.returnType((newOperatorToken(start, str)), Token); - }, - scanIdentifier: function() { - assert(isIdentifierStart(this.peek)); - var start = assert.type(this.index, int); - this.advance(); - while (isIdentifierPart(this.peek)) - this.advance(); - var str = assert.type(this.input.substring(start, this.index), assert.type.string); - if (SetWrapper.has(KEYWORDS, str)) { - return assert.returnType((newKeywordToken(start, str)), Token); + } + }, {}); + }()); + _AsyncInjectorStrategy = (function() { + function _AsyncInjectorStrategy(injector) { + this.injector = injector; + } + return ($traceurRuntime.createClass)(_AsyncInjectorStrategy, { + readFromCache: function(key) { + if (key.token === Injector) { + return PromiseWrapper.resolve(this.injector); + } + var instance = this.injector._getInstance(key); + if (instance === _constructing) { + throw new CyclicDependencyError(key); + } else if (_isWaiting(instance)) { + return instance.promise; + } else if (isPresent(instance)) { + return PromiseWrapper.resolve(instance); } else { - return assert.returnType((newIdentifierToken(start, str)), Token); + return _notFound; } }, - scanNumber: function(start) { - assert.argumentTypes(start, int); - assert(isDigit(this.peek)); - var simple = assert.type((this.index === start), assert.type.boolean); - this.advance(); - while (true) { - if (isDigit(this.peek)) {} else if (this.peek == $PERIOD) { - simple = false; - } else if (isExponentStart(this.peek)) { - this.advance(); - if (isExponentSign(this.peek)) - this.advance(); - if (!isDigit(this.peek)) - this.error('Invalid exponent', -1); - simple = false; - } else { - break; - } - this.advance(); - } - var str = assert.type(this.input.substring(start, this.index), assert.type.string); - var value = assert.type(simple ? NumberWrapper.parseIntAutoRadix(str) : NumberWrapper.parseFloat(str), assert.type.number); - return assert.returnType((newNumberToken(start, value)), Token); + instantiate: function(key) { + var $__0 = this; + var binding = this.injector._getBinding(key); + if (isBlank(binding)) + return _notFound; + this.injector._markAsConstructing(key); + var deps = this.injector._resolveDependencies(key, binding, true); + var depsPromise = PromiseWrapper.all(deps); + var promise = PromiseWrapper.then(depsPromise, null, (function(e) { + return $__0._errorHandler(key, e); + })).then((function(deps) { + return $__0._findOrCreate(key, binding, deps); + })).then((function(instance) { + return $__0._cacheInstance(key, instance); + })); + this.injector._setInstance(key, new _Waiting(promise)); + return promise; }, - scanString: function() { - assert(this.peek == $SQ || this.peek == $DQ); - var start = assert.type(this.index, int); - var quote = assert.type(this.peek, int); - this.advance(); - var buffer; - var marker = assert.type(this.index, int); - var input = assert.type(this.input, assert.type.string); - while (this.peek != quote) { - if (this.peek == $BACKSLASH) { - if (buffer == null) - buffer = new StringJoiner(); - buffer.add(input.substring(marker, this.index)); - this.advance(); - var unescapedCode = void 0; - if (this.peek == $u) { - var hex = assert.type(input.substring(this.index + 1, this.index + 5), assert.type.string); - try { - unescapedCode = NumberWrapper.parseInt(hex, 16); - } catch (e) { - this.error(("Invalid unicode escape [\\u" + hex + "]"), 0); - } - for (var i = assert.type(0, int); i < 5; i++) { - this.advance(); - } - } else { - unescapedCode = unescape(this.peek); - this.advance(); - } - buffer.add(StringWrapper.fromCharCode(unescapedCode)); - marker = this.index; - } else if (this.peek == $EOF) { - this.error('Unterminated quote', 0); - } else { - this.advance(); - } - } - var last = assert.type(input.substring(marker, this.index), assert.type.string); - this.advance(); - var unescaped = assert.type(last, assert.type.string); - if (buffer != null) { - buffer.add(last); - unescaped = buffer.toString(); + _errorHandler: function(key, e) { + if (e instanceof AbstractBindingError) + e.addKey(key); + return PromiseWrapper.reject(e); + }, + _findOrCreate: function(key, binding, deps) { + try { + var instance = this.injector._getInstance(key); + if (!_isWaiting(instance)) + return instance; + return FunctionWrapper.apply(binding.factory, deps); + } catch (e) { + this.injector._clear(key); + throw new InstantiationError(e, key); } - return assert.returnType((newStringToken(start, unescaped)), Token); }, - error: function(message, offset) { - assert.argumentTypes(message, assert.type.string, offset, int); - var position = assert.type(this.index + offset, int); - throw new ScannerError(("Lexer Error: " + message + " at column " + position + " in expression [" + this.input + "]")); + _cacheInstance: function(key, instance) { + this.injector._setInstance(key, instance); + return instance; } }, {}); }()); - Object.defineProperty(_Scanner, "parameters", {get: function() { - return [[assert.type.string]]; - }}); - Object.defineProperty(_Scanner.prototype.scanCharacter, "parameters", {get: function() { - return [[int], [int]]; - }}); - Object.defineProperty(_Scanner.prototype.scanOperator, "parameters", {get: function() { - return [[int], [assert.type.string]]; - }}); - Object.defineProperty(_Scanner.prototype.scanComplexOperator, "parameters", {get: function() { - return [[int], [int], [assert.type.string], [assert.type.string]]; - }}); - Object.defineProperty(_Scanner.prototype.scanNumber, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(_Scanner.prototype.error, "parameters", {get: function() { - return [[assert.type.string], [int]]; - }}); - Object.defineProperty(isWhitespace, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(isIdentifierStart, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(isIdentifierPart, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(isDigit, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(isExponentStart, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(isExponentSign, "parameters", {get: function() { - return [[int]]; - }}); - Object.defineProperty(unescape, "parameters", {get: function() { - return [[int]]; - }}); - OPERATORS = SetWrapper.createFromList(['+', '-', '*', '/', '%', '^', '=', '==', '!=', '===', '!==', '<', '>', '<=', '>=', '&&', '||', '&', '|', '!', '?', '#']); - KEYWORDS = SetWrapper.createFromList(['var', 'null', 'undefined', 'true', 'false']); } }; }); -System.register("angular2/src/core/compiler/element_ref", ["rtts_assert/rtts_assert", "angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/core/compiler/view_ref", "angular2/src/render/dom/direct_dom_renderer"], function($__export) { +System.register("angular2/src/core/compiler/element_ref", ["angular2/src/dom/dom_adapter", "angular2/src/facade/lang", "angular2/src/core/compiler/view_ref", "angular2/src/render/dom/view/view"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/element_ref"; - var assert, - DOM, + var DOM, normalizeBlank, ViewRef, - DirectDomViewRef, + resolveInternalDomView, ElementRef; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { DOM = $__m.DOM; }, function($__m) { normalizeBlank = $__m.normalizeBlank; }, function($__m) { ViewRef = $__m.ViewRef; }, function($__m) { - DirectDomViewRef = $__m.DirectDomViewRef; + resolveInternalDomView = $__m.resolveInternalDomView; }], execute: function() { ElementRef = (function() { function ElementRef(parentView, boundElementIndex) { - assert.argumentTypes(parentView, ViewRef, boundElementIndex, assert.type.number); this.parentView = parentView; this.boundElementIndex = boundElementIndex; } return ($traceurRuntime.createClass)(ElementRef, { get domElement() { - var renderViewRef = assert.type(this.parentView.render, DirectDomViewRef); - return renderViewRef.delegate.boundElements[this.boundElementIndex]; + return resolveInternalDomView(this.parentView.render).boundElements[this.boundElementIndex]; }, getAttribute: function(name) { - assert.argumentTypes(name, assert.type.string); - return assert.returnType((normalizeBlank(DOM.getAttribute(this.domElement, name))), assert.type.string); + return normalizeBlank(DOM.getAttribute(this.domElement, name)); } }, {}); }()); @@ -27934,9 +22939,93 @@ System.register("angular2/src/core/compiler/element_ref", ["rtts_assert/rtts_ass }; }); -System.register("angular2/change_detection", ["angular2/src/change_detection/parser/ast", "angular2/src/change_detection/parser/lexer", "angular2/src/change_detection/parser/parser", "angular2/src/change_detection/parser/locals", "angular2/src/change_detection/exceptions", "angular2/src/change_detection/interfaces", "angular2/src/change_detection/constants", "angular2/src/change_detection/proto_change_detector", "angular2/src/change_detection/binding_record", "angular2/src/change_detection/directive_record", "angular2/src/change_detection/dynamic_change_detector", "angular2/src/change_detection/change_detector_ref", "angular2/src/change_detection/pipes/pipe_registry", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/pipes/pipe", "angular2/src/change_detection/change_detection"], function($__export) { +System.register("angular2/src/render/dom/compiler/compile_pipeline", ["angular2/src/facade/lang", "angular2/src/facade/collection", "angular2/src/dom/dom_adapter", "angular2/src/render/dom/compiler/compile_element", "angular2/src/render/dom/compiler/compile_control", "angular2/src/render/dom/compiler/compile_step", "angular2/src/render/dom/view/proto_view_builder"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/render/dom/compiler/compile_pipeline"; + var isPresent, + List, + ListWrapper, + DOM, + CompileElement, + CompileControl, + CompileStep, + ProtoViewBuilder, + CompilePipeline; + return { + setters: [function($__m) { + isPresent = $__m.isPresent; + }, function($__m) { + List = $__m.List; + ListWrapper = $__m.ListWrapper; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + CompileElement = $__m.CompileElement; + }, function($__m) { + CompileControl = $__m.CompileControl; + }, function($__m) { + CompileStep = $__m.CompileStep; + }, function($__m) { + ProtoViewBuilder = $__m.ProtoViewBuilder; + }], + execute: function() { + CompilePipeline = (function() { + function CompilePipeline(steps) { + this._control = new CompileControl(steps); + } + return ($traceurRuntime.createClass)(CompilePipeline, { + process: function(rootElement) { + var compilationCtxtDescription = arguments[1] !== (void 0) ? arguments[1] : ''; + var results = ListWrapper.create(); + var rootCompileElement = new CompileElement(rootElement, compilationCtxtDescription); + rootCompileElement.inheritedProtoView = new ProtoViewBuilder(rootElement); + rootCompileElement.isViewRoot = true; + this._process(results, null, rootCompileElement, compilationCtxtDescription); + return results; + }, + _process: function(results, parent, current) { + var compilationCtxtDescription = arguments[3] !== (void 0) ? arguments[3] : ''; + var additionalChildren = this._control.internalProcess(results, 0, parent, current); + if (current.compileChildren) { + var node = DOM.firstChild(DOM.templateAwareRoot(current.element)); + while (isPresent(node)) { + var nextNode = DOM.nextSibling(node); + if (DOM.isElementNode(node)) { + var childCompileElement = new CompileElement(node, compilationCtxtDescription); + childCompileElement.inheritedProtoView = current.inheritedProtoView; + childCompileElement.inheritedElementBinder = current.inheritedElementBinder; + childCompileElement.distanceToInheritedBinder = current.distanceToInheritedBinder + 1; + this._process(results, current, childCompileElement); + } + node = nextNode; + } + } + if (isPresent(additionalChildren)) { + for (var i = 0; i < additionalChildren.length; i++) { + this._process(results, current, additionalChildren[i]); + } + } + } + }, {}); + }()); + $__export("CompilePipeline", CompilePipeline); + Object.defineProperty(CompilePipeline, "parameters", {get: function() { + return [[assert.genericType(List, CompileStep)]]; + }}); + Object.defineProperty(CompilePipeline.prototype.process, "parameters", {get: function() { + return [[], [assert.type.string]]; + }}); + Object.defineProperty(CompilePipeline.prototype._process, "parameters", {get: function() { + return [[], [CompileElement], [CompileElement], [assert.type.string]]; + }}); + } + }; +}); + +System.register("angular2/change_detection", ["angular2/src/change_detection/parser/ast", "angular2/src/change_detection/parser/lexer", "angular2/src/change_detection/parser/parser", "angular2/src/change_detection/parser/locals", "angular2/src/change_detection/exceptions", "angular2/src/change_detection/interfaces", "angular2/src/change_detection/constants", "angular2/src/change_detection/proto_change_detector", "angular2/src/change_detection/binding_record", "angular2/src/change_detection/directive_record", "angular2/src/change_detection/dynamic_change_detector", "angular2/src/change_detection/change_detector_ref", "angular2/src/change_detection/pipes/pipe_registry", "angular2/src/change_detection/change_detection_util", "angular2/src/change_detection/pipes/pipe", "angular2/src/change_detection/pipes/null_pipe", "angular2/src/change_detection/change_detection"], function($__export) { "use strict"; var __moduleName = "angular2/change_detection"; + var __esModule; return { setters: [function($__m) { $__export("ASTWithSource", $__m.ASTWithSource); @@ -27985,28 +23074,80 @@ System.register("angular2/change_detection", ["angular2/src/change_detection/par }, function($__m) { $__export("WrappedValue", $__m.WrappedValue); $__export("Pipe", $__m.Pipe); + }, function($__m) { + $__export("NullPipe", $__m.NullPipe); + $__export("NullPipeFactory", $__m.NullPipeFactory); }, function($__m) { $__export("defaultPipes", $__m.defaultPipes); $__export("DynamicChangeDetection", $__m.DynamicChangeDetection); $__export("JitChangeDetection", $__m.JitChangeDetection); $__export("defaultPipeRegistry", $__m.defaultPipeRegistry); }], - execute: function() {} + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + } }; }); -System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/collection", "angular2/src/facade/lang", "angular2/src/core/compiler/view", "angular2/src/core/compiler/element_ref", "angular2/src/core/compiler/view_ref", "angular2/src/core/compiler/view_container_ref", "angular2/src/render/api", "angular2/src/core/compiler/view_manager_utils", "angular2/src/core/compiler/view_pool"], function($__export) { +System.register("angular2/di", ["angular2/src/di/annotations", "angular2/src/di/decorators", "angular2/src/di/injector", "angular2/src/di/binding", "angular2/src/di/key", "angular2/src/di/exceptions", "angular2/src/di/opaque_token"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/compiler/view_manager"; - var assert, - Injector, - Injectable, - Binding, - ListWrapper, - MapWrapper, - Map, - StringMapWrapper, - List, + var __moduleName = "angular2/di"; + var __esModule; + var $__exportNames = { + __esModule: true, + undefined: true + }; + var $__exportNames = { + __esModule: true, + undefined: true + }; + return { + setters: [function($__m) { + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + Object.keys($__m).forEach(function(p) { + if (!$__exportNames[p]) + $__export(p, $__m[p]); + }); + }, function($__m) { + $__export("Injector", $__m.Injector); + }, function($__m) { + $__export("Binding", $__m.Binding); + $__export("ResolvedBinding", $__m.ResolvedBinding); + $__export("Dependency", $__m.Dependency); + $__export("bind", $__m.bind); + }, function($__m) { + $__export("Key", $__m.Key); + $__export("KeyRegistry", $__m.KeyRegistry); + $__export("TypeLiteral", $__m.TypeLiteral); + }, function($__m) { + $__export("NoBindingError", $__m.NoBindingError); + $__export("AbstractBindingError", $__m.AbstractBindingError); + $__export("AsyncBindingError", $__m.AsyncBindingError); + $__export("CyclicDependencyError", $__m.CyclicDependencyError); + $__export("InstantiationError", $__m.InstantiationError); + $__export("InvalidBindingError", $__m.InvalidBindingError); + $__export("NoAnnotationError", $__m.NoAnnotationError); + }, function($__m) { + $__export("OpaqueToken", $__m.OpaqueToken); + }], + execute: function() { + __esModule = true; + $__export("__esModule", __esModule); + } + }; +}); + +System.register("angular2/src/core/compiler/view_manager", ["angular2/di", "angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/core/compiler/view", "angular2/src/core/compiler/element_ref", "angular2/src/core/compiler/view_ref", "angular2/src/core/compiler/view_container_ref", "angular2/src/render/api", "angular2/src/core/compiler/view_manager_utils", "angular2/src/core/compiler/view_pool"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/compiler/view_manager"; + var Injector, + Binding, + Injectable, isPresent, isBlank, BaseException, @@ -28019,23 +23160,15 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as ViewContainerRef, Renderer, RenderViewRef, - RenderViewContainerRef, AppViewManagerUtils, AppViewPool, AppViewManager; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injector = $__m.Injector; - Injectable = $__m.Injectable; Binding = $__m.Binding; }, function($__m) { - ListWrapper = $__m.ListWrapper; - MapWrapper = $__m.MapWrapper; - Map = $__m.Map; - StringMapWrapper = $__m.StringMapWrapper; - List = $__m.List; + Injectable = $__m.Injectable; }, function($__m) { isPresent = $__m.isPresent; isBlank = $__m.isBlank; @@ -28054,7 +23187,6 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as }, function($__m) { Renderer = $__m.Renderer; RenderViewRef = $__m.RenderViewRef; - RenderViewContainerRef = $__m.RenderViewContainerRef; }, function($__m) { AppViewManagerUtils = $__m.AppViewManagerUtils; }, function($__m) { @@ -28063,25 +23195,26 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as execute: function() { AppViewManager = (function() { function AppViewManager(viewPool, utils, renderer) { - assert.argumentTypes(viewPool, AppViewPool, utils, AppViewManagerUtils, renderer, Renderer); this._renderer = renderer; this._viewPool = viewPool; this._utils = utils; } return ($traceurRuntime.createClass)(AppViewManager, { + getComponentView: function(hostLocation) { + var hostView = internalView(hostLocation.parentView); + var boundElementIndex = hostLocation.boundElementIndex; + return new ViewRef(hostView.componentChildViews[boundElementIndex]); + }, getViewContainer: function(location) { - assert.argumentTypes(location, ElementRef); var hostView = internalView(location.parentView); - return assert.returnType((hostView.elementInjectors[location.boundElementIndex].getViewContainerRef()), ViewContainerRef); + return hostView.elementInjectors[location.boundElementIndex].getViewContainerRef(); }, getComponent: function(hostLocation) { - assert.argumentTypes(hostLocation, ElementRef); var hostView = internalView(hostLocation.parentView); var boundElementIndex = hostLocation.boundElementIndex; - return assert.returnType((this._utils.getComponentInstance(hostView, boundElementIndex)), assert.type.any); + return this._utils.getComponentInstance(hostView, boundElementIndex); }, createDynamicComponentView: function(hostLocation, componentProtoViewRef, componentBinding, injector) { - assert.argumentTypes(hostLocation, ElementRef, componentProtoViewRef, ProtoViewRef, componentBinding, Binding, injector, Injector); var componentProtoView = internalProtoView(componentProtoViewRef); var hostView = internalView(hostLocation.parentView); var boundElementIndex = hostLocation.boundElementIndex; @@ -28089,17 +23222,15 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as if (!binder.hasDynamicComponent()) { throw new BaseException(("There is no dynamic component directive at element " + boundElementIndex)); } - var componentView = this._createViewRecurse(componentProtoView); - var renderViewRefs = this._renderer.createDynamicComponentView(hostView.render, boundElementIndex, componentProtoView.render); - componentView.render = renderViewRefs[0]; + var componentView = this._createPooledView(componentProtoView); + this._renderer.attachComponentView(hostView.render, boundElementIndex, componentView.render); this._utils.attachComponentView(hostView, boundElementIndex, componentView); this._utils.hydrateDynamicComponentInElementInjector(hostView, boundElementIndex, componentBinding, injector); this._utils.hydrateComponentView(hostView, boundElementIndex); - this._viewHydrateRecurse(componentView, renderViewRefs, 1); - return assert.returnType((new ViewRef(componentView)), ViewRef); + this._viewHydrateRecurse(componentView); + return new ViewRef(componentView); }, createInPlaceHostView: function(parentComponentLocation, hostElementSelector, hostProtoViewRef, injector) { - assert.argumentTypes(parentComponentLocation, ElementRef, hostElementSelector, assert.type.any, hostProtoViewRef, ProtoViewRef, injector, Injector); var hostProtoView = internalProtoView(hostProtoViewRef); var parentComponentHostView = null; var parentComponentBoundElementIndex = null; @@ -28109,140 +23240,143 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as parentComponentBoundElementIndex = parentComponentLocation.boundElementIndex; parentRenderViewRef = parentComponentHostView.componentChildViews[parentComponentBoundElementIndex].render; } - var hostView = this._createViewRecurse(hostProtoView); - var renderViewRefs = this._renderer.createInPlaceHostView(parentRenderViewRef, hostElementSelector, hostProtoView.render); - hostView.render = renderViewRefs[0]; + var hostRenderView = this._renderer.createInPlaceHostView(parentRenderViewRef, hostElementSelector, hostProtoView.render); + var hostView = this._utils.createView(hostProtoView, hostRenderView, this, this._renderer); + this._renderer.setEventDispatcher(hostView.render, hostView); + this._createViewRecurse(hostView); this._utils.attachAndHydrateInPlaceHostView(parentComponentHostView, parentComponentBoundElementIndex, hostView, injector); - this._viewHydrateRecurse(hostView, renderViewRefs, 1); - return assert.returnType((new ViewRef(hostView)), ViewRef); + this._viewHydrateRecurse(hostView); + return new ViewRef(hostView); }, destroyInPlaceHostView: function(parentComponentLocation, hostViewRef) { - assert.argumentTypes(parentComponentLocation, ElementRef, hostViewRef, ViewRef); var hostView = internalView(hostViewRef); var parentView = null; - var parentRenderViewRef = null; if (isPresent(parentComponentLocation)) { parentView = internalView(parentComponentLocation.parentView).componentChildViews[parentComponentLocation.boundElementIndex]; - parentRenderViewRef = parentView.render; } - var hostViewRenderRef = hostView.render; - this._viewDehydrateRecurse(hostView); - this._utils.detachInPlaceHostView(parentView, hostView); - this._renderer.destroyInPlaceHostView(parentRenderViewRef, hostViewRenderRef); - this._destroyView(hostView); + this._destroyInPlaceHostView(parentView, hostView); }, createViewInContainer: function(viewContainerLocation, atIndex, protoViewRef) { - var injector = arguments[3] !== (void 0) ? arguments[3] : null; - assert.argumentTypes(viewContainerLocation, ElementRef, atIndex, assert.type.number, protoViewRef, ProtoViewRef, injector, Injector); + var context = arguments[3] !== (void 0) ? arguments[3] : null; + var injector = arguments[4] !== (void 0) ? arguments[4] : null; var protoView = internalProtoView(protoViewRef); var parentView = internalView(viewContainerLocation.parentView); var boundElementIndex = viewContainerLocation.boundElementIndex; - var view = this._createViewRecurse(protoView); - var renderViewRefs = this._renderer.createViewInContainer(this._getRenderViewContainerRef(parentView, boundElementIndex), atIndex, view.proto.render); - view.render = renderViewRefs[0]; - this._utils.attachViewInContainer(parentView, boundElementIndex, atIndex, view); - this._utils.hydrateViewInContainer(parentView, boundElementIndex, atIndex, injector); - this._viewHydrateRecurse(view, renderViewRefs, 1); - return assert.returnType((new ViewRef(view)), ViewRef); + var contextView = null; + var contextBoundElementIndex = null; + if (isPresent(context)) { + contextView = internalView(context.parentView); + contextBoundElementIndex = context.boundElementIndex; + } + var view = this._createPooledView(protoView); + this._renderer.attachViewInContainer(parentView.render, boundElementIndex, atIndex, view.render); + this._utils.attachViewInContainer(parentView, boundElementIndex, contextView, contextBoundElementIndex, atIndex, view); + this._utils.hydrateViewInContainer(parentView, boundElementIndex, contextView, contextBoundElementIndex, atIndex, injector); + this._viewHydrateRecurse(view); + return new ViewRef(view); }, destroyViewInContainer: function(viewContainerLocation, atIndex) { - assert.argumentTypes(viewContainerLocation, ElementRef, atIndex, assert.type.number); var parentView = internalView(viewContainerLocation.parentView); var boundElementIndex = viewContainerLocation.boundElementIndex; - var viewContainer = parentView.viewContainers[boundElementIndex]; - var view = viewContainer.views[atIndex]; - this._viewDehydrateRecurse(view); - this._utils.detachViewInContainer(parentView, boundElementIndex, atIndex); - this._renderer.destroyViewInContainer(this._getRenderViewContainerRef(parentView, boundElementIndex), atIndex); - this._destroyView(view); + this._destroyViewInContainer(parentView, boundElementIndex, atIndex); }, attachViewInContainer: function(viewContainerLocation, atIndex, viewRef) { - assert.argumentTypes(viewContainerLocation, ElementRef, atIndex, assert.type.number, viewRef, ViewRef); var view = internalView(viewRef); var parentView = internalView(viewContainerLocation.parentView); var boundElementIndex = viewContainerLocation.boundElementIndex; - this._utils.attachViewInContainer(parentView, boundElementIndex, atIndex, view); - this._renderer.insertViewIntoContainer(this._getRenderViewContainerRef(parentView, boundElementIndex), atIndex, view.render); - return assert.returnType((viewRef), ViewRef); + this._utils.attachViewInContainer(parentView, boundElementIndex, null, null, atIndex, view); + this._renderer.attachViewInContainer(parentView.render, boundElementIndex, atIndex, view.render); + return viewRef; }, detachViewInContainer: function(viewContainerLocation, atIndex) { - assert.argumentTypes(viewContainerLocation, ElementRef, atIndex, assert.type.number); var parentView = internalView(viewContainerLocation.parentView); var boundElementIndex = viewContainerLocation.boundElementIndex; var viewContainer = parentView.viewContainers[boundElementIndex]; var view = viewContainer.views[atIndex]; this._utils.detachViewInContainer(parentView, boundElementIndex, atIndex); - this._renderer.detachViewFromContainer(this._getRenderViewContainerRef(parentView, boundElementIndex), atIndex); - return assert.returnType((new ViewRef(view)), ViewRef); - }, - _getRenderViewContainerRef: function(parentView, boundElementIndex) { - assert.argumentTypes(parentView, viewModule.AppView, boundElementIndex, assert.type.number); - return new RenderViewContainerRef(parentView.render, boundElementIndex); + this._renderer.detachViewInContainer(parentView.render, boundElementIndex, atIndex, view.render); + return new ViewRef(view); }, - _createViewRecurse: function(protoView) { - assert.argumentTypes(protoView, viewModule.AppProtoView); + _createPooledView: function(protoView) { var view = this._viewPool.getView(protoView); if (isBlank(view)) { - view = this._utils.createView(protoView, this, this._renderer); - var binders = protoView.elementBinders; - for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { - var binder = binders[binderIdx]; - if (binder.hasStaticComponent()) { - var childView = this._createViewRecurse(binder.nestedProtoView); - this._utils.attachComponentView(view, binderIdx, childView); - } - } + view = this._utils.createView(protoView, this._renderer.createView(protoView.render), this, this._renderer); + this._renderer.setEventDispatcher(view.render, view); + this._createViewRecurse(view); } return view; }, - _destroyView: function(view) { - assert.argumentTypes(view, viewModule.AppView); + _createViewRecurse: function(view) { + var binders = view.proto.elementBinders; + for (var binderIdx = 0; binderIdx < binders.length; binderIdx++) { + var binder = binders[binderIdx]; + if (binder.hasStaticComponent()) { + var childView = this._createPooledView(binder.nestedProtoView); + this._renderer.attachComponentView(view.render, binderIdx, childView.render); + this._utils.attachComponentView(view, binderIdx, childView); + } + } + }, + _destroyPooledView: function(view) { this._viewPool.returnView(view); }, - _viewHydrateRecurse: function(view, renderComponentViewRefs, renderComponentIndex) { - assert.argumentTypes(view, viewModule.AppView, renderComponentViewRefs, assert.genericType(List, RenderViewRef), renderComponentIndex, assert.type.number); - this._renderer.setEventDispatcher(view.render, view); + _destroyViewInContainer: function(parentView, boundElementIndex, atIndex) { + var viewContainer = parentView.viewContainers[boundElementIndex]; + var view = viewContainer.views[atIndex]; + this._viewDehydrateRecurse(view, false); + this._utils.detachViewInContainer(parentView, boundElementIndex, atIndex); + this._renderer.detachViewInContainer(parentView.render, boundElementIndex, atIndex, view.render); + this._destroyPooledView(view); + }, + _destroyComponentView: function(hostView, boundElementIndex, componentView) { + this._viewDehydrateRecurse(componentView, false); + this._renderer.detachComponentView(hostView.render, boundElementIndex, componentView.render); + this._utils.detachComponentView(hostView, boundElementIndex); + this._destroyPooledView(componentView); + }, + _destroyInPlaceHostView: function(parentView, hostView) { + var parentRenderViewRef = null; + if (isPresent(parentView)) { + parentRenderViewRef = parentView.render; + } + this._viewDehydrateRecurse(hostView, true); + this._utils.detachInPlaceHostView(parentView, hostView); + this._renderer.destroyInPlaceHostView(parentRenderViewRef, hostView.render); + }, + _viewHydrateRecurse: function(view) { + this._renderer.hydrateView(view.render); var binders = view.proto.elementBinders; for (var i = 0; i < binders.length; ++i) { if (binders[i].hasStaticComponent()) { - var childView = view.componentChildViews[i]; - childView.render = renderComponentViewRefs[renderComponentIndex++]; this._utils.hydrateComponentView(view, i); - renderComponentIndex = this._viewHydrateRecurse(view.componentChildViews[i], renderComponentViewRefs, renderComponentIndex); + this._viewHydrateRecurse(view.componentChildViews[i]); } } - return assert.returnType((renderComponentIndex), assert.type.number); }, - _viewDehydrateRecurse: function(view) { - assert.argumentTypes(view, viewModule.AppView); + _viewDehydrateRecurse: function(view, forceDestroyComponents) { this._utils.dehydrateView(view); + this._renderer.dehydrateView(view.render); var binders = view.proto.elementBinders; for (var i = 0; i < binders.length; i++) { var componentView = view.componentChildViews[i]; if (isPresent(componentView)) { - this._viewDehydrateRecurse(componentView); - if (binders[i].hasDynamicComponent()) { - this._utils.detachComponentView(view, i); - this._destroyView(componentView); + if (binders[i].hasDynamicComponent() || forceDestroyComponents) { + this._destroyComponentView(view, i, componentView); + } else { + this._viewDehydrateRecurse(componentView, false); } } var vc = view.viewContainers[i]; if (isPresent(vc)) { for (var j = vc.views.length - 1; j >= 0; j--) { - var childView = vc.views[j]; - this._viewDehydrateRecurse(childView); - this._utils.detachViewInContainer(view, i, j); - this._destroyView(childView); + this._destroyViewInContainer(view, i, j); } } } - for (var i = 0; i < view.imperativeHostViews.length; i++) { - var hostView = view.imperativeHostViews[i]; - this._viewDehydrateRecurse(hostView); - this._utils.detachInPlaceHostView(view, hostView); - this._destroyView(hostView); + for (var i = view.inPlaceHostViews.length - 1; i >= 0; i--) { + var hostView = view.inPlaceHostViews[i]; + this._destroyInPlaceHostView(view, hostView); } - view.render = null; } }, {}); }()); @@ -28253,6 +23387,9 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as Object.defineProperty(AppViewManager, "parameters", {get: function() { return [[AppViewPool], [AppViewManagerUtils], [Renderer]]; }}); + Object.defineProperty(AppViewManager.prototype.getComponentView, "parameters", {get: function() { + return [[ElementRef]]; + }}); Object.defineProperty(AppViewManager.prototype.getViewContainer, "parameters", {get: function() { return [[ElementRef]]; }}); @@ -28263,13 +23400,13 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as return [[ElementRef], [ProtoViewRef], [Binding], [Injector]]; }}); Object.defineProperty(AppViewManager.prototype.createInPlaceHostView, "parameters", {get: function() { - return [[ElementRef], [], [ProtoViewRef], [Injector]]; + return [[ElementRef], [assert.type.string], [ProtoViewRef], [Injector]]; }}); Object.defineProperty(AppViewManager.prototype.destroyInPlaceHostView, "parameters", {get: function() { return [[ElementRef], [ViewRef]]; }}); Object.defineProperty(AppViewManager.prototype.createViewInContainer, "parameters", {get: function() { - return [[ElementRef], [assert.type.number], [ProtoViewRef], [Injector]]; + return [[ElementRef], [assert.type.number], [ProtoViewRef], [ElementRef], [Injector]]; }}); Object.defineProperty(AppViewManager.prototype.destroyViewInContainer, "parameters", {get: function() { return [[ElementRef], [assert.type.number]]; @@ -28280,40 +23417,167 @@ System.register("angular2/src/core/compiler/view_manager", ["rtts_assert/rtts_as Object.defineProperty(AppViewManager.prototype.detachViewInContainer, "parameters", {get: function() { return [[ElementRef], [assert.type.number]]; }}); - Object.defineProperty(AppViewManager.prototype._getRenderViewContainerRef, "parameters", {get: function() { - return [[viewModule.AppView], [assert.type.number]]; + Object.defineProperty(AppViewManager.prototype._createPooledView, "parameters", {get: function() { + return [[viewModule.AppProtoView]]; }}); Object.defineProperty(AppViewManager.prototype._createViewRecurse, "parameters", {get: function() { - return [[viewModule.AppProtoView]]; + return [[viewModule.AppView]]; }}); - Object.defineProperty(AppViewManager.prototype._destroyView, "parameters", {get: function() { + Object.defineProperty(AppViewManager.prototype._destroyPooledView, "parameters", {get: function() { return [[viewModule.AppView]]; }}); + Object.defineProperty(AppViewManager.prototype._destroyViewInContainer, "parameters", {get: function() { + return [[], [], [assert.type.number]]; + }}); Object.defineProperty(AppViewManager.prototype._viewHydrateRecurse, "parameters", {get: function() { - return [[viewModule.AppView], [assert.genericType(List, RenderViewRef)], [assert.type.number]]; + return [[viewModule.AppView]]; }}); Object.defineProperty(AppViewManager.prototype._viewDehydrateRecurse, "parameters", {get: function() { - return [[viewModule.AppView]]; + return [[viewModule.AppView], []]; }}); } }; }); -System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtts_assert", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/math", "angular2/src/facade/collection", "angular2/di", "angular2/src/core/annotations_impl/visibility", "angular2/src/core/annotations_impl/di", "angular2/src/core/compiler/view", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/element_ref", "angular2/src/core/compiler/view_ref", "angular2/src/core/annotations_impl/annotations", "angular2/change_detection", "angular2/src/core/compiler/query_list", "angular2/src/reflection/reflection"], function($__export) { +System.register("angular2/src/render/dom/compiler/compiler", ["angular2/src/di/annotations_impl", "angular2/src/facade/async", "angular2/src/facade/lang", "angular2/src/dom/dom_adapter", "angular2/src/render/api", "angular2/src/render/dom/compiler/compile_pipeline", "angular2/src/render/dom/compiler/template_loader", "angular2/src/render/dom/compiler/compile_step_factory", "angular2/change_detection", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy"], function($__export) { "use strict"; - var __moduleName = "angular2/src/core/compiler/element_injector"; - var assert, + var __moduleName = "angular2/src/render/dom/compiler/compiler"; + var Injectable, + PromiseWrapper, + Promise, + BaseException, isPresent, + DOM, + ViewDefinition, + ProtoViewDto, + DirectiveMetadata, + RenderCompiler, + RenderProtoViewRef, + CompilePipeline, + TemplateLoader, + CompileStepFactory, + DefaultStepFactory, + Parser, + ShadowDomStrategy, + DomCompiler, + DefaultDomCompiler; + return { + setters: [function($__m) { + Injectable = $__m.Injectable; + }, function($__m) { + PromiseWrapper = $__m.PromiseWrapper; + Promise = $__m.Promise; + }, function($__m) { + BaseException = $__m.BaseException; + isPresent = $__m.isPresent; + }, function($__m) { + DOM = $__m.DOM; + }, function($__m) { + ViewDefinition = $__m.ViewDefinition; + ProtoViewDto = $__m.ProtoViewDto; + DirectiveMetadata = $__m.DirectiveMetadata; + RenderCompiler = $__m.RenderCompiler; + RenderProtoViewRef = $__m.RenderProtoViewRef; + }, function($__m) { + CompilePipeline = $__m.CompilePipeline; + }, function($__m) { + TemplateLoader = $__m.TemplateLoader; + }, function($__m) { + CompileStepFactory = $__m.CompileStepFactory; + DefaultStepFactory = $__m.DefaultStepFactory; + }, function($__m) { + Parser = $__m.Parser; + }, function($__m) { + ShadowDomStrategy = $__m.ShadowDomStrategy; + }], + execute: function() { + DomCompiler = (function($__super) { + function DomCompiler(stepFactory, templateLoader) { + $traceurRuntime.superConstructor(DomCompiler).call(this); + this._templateLoader = templateLoader; + this._stepFactory = stepFactory; + } + return ($traceurRuntime.createClass)(DomCompiler, { + compile: function(template) { + var $__0 = this; + var tplPromise = this._templateLoader.load(template); + return PromiseWrapper.then(tplPromise, (function(el) { + return $__0._compileTemplate(template, el); + }), (function(_) { + throw new BaseException(("Failed to load the template \"" + template.componentId + "\"")); + })); + }, + compileHost: function(directiveMetadata) { + var hostViewDef = new ViewDefinition({ + componentId: directiveMetadata.id, + absUrl: null, + template: null, + directives: [directiveMetadata] + }); + var element = DOM.createElement(directiveMetadata.selector); + return this._compileTemplate(hostViewDef, element); + }, + _compileTemplate: function(viewDef, tplElement) { + var subTaskPromises = []; + var pipeline = new CompilePipeline(this._stepFactory.createSteps(viewDef, subTaskPromises)); + var compileElements = pipeline.process(tplElement, viewDef.componentId); + var protoView = compileElements[0].inheritedProtoView.build(); + if (subTaskPromises.length > 0) { + return PromiseWrapper.all(subTaskPromises).then((function(_) { + return protoView; + })); + } else { + return PromiseWrapper.resolve(protoView); + } + } + }, {}, $__super); + }(RenderCompiler)); + $__export("DomCompiler", DomCompiler); + Object.defineProperty(DomCompiler, "parameters", {get: function() { + return [[CompileStepFactory], [TemplateLoader]]; + }}); + Object.defineProperty(DomCompiler.prototype.compile, "parameters", {get: function() { + return [[ViewDefinition]]; + }}); + Object.defineProperty(DomCompiler.prototype.compileHost, "parameters", {get: function() { + return [[DirectiveMetadata]]; + }}); + Object.defineProperty(DomCompiler.prototype._compileTemplate, "parameters", {get: function() { + return [[ViewDefinition], []]; + }}); + DefaultDomCompiler = (function($__super) { + function DefaultDomCompiler(parser, shadowDomStrategy, templateLoader) { + $traceurRuntime.superConstructor(DefaultDomCompiler).call(this, new DefaultStepFactory(parser, shadowDomStrategy), templateLoader); + } + return ($traceurRuntime.createClass)(DefaultDomCompiler, {}, {}, $__super); + }(DomCompiler)); + $__export("DefaultDomCompiler", DefaultDomCompiler); + Object.defineProperty(DefaultDomCompiler, "annotations", {get: function() { + return [new Injectable()]; + }}); + Object.defineProperty(DefaultDomCompiler, "parameters", {get: function() { + return [[Parser], [ShadowDomStrategy], [TemplateLoader]]; + }}); + } + }; +}); + +System.register("angular2/src/core/compiler/element_injector", ["angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/math", "angular2/src/facade/collection", "angular2/di", "angular2/src/core/annotations_impl/visibility", "angular2/src/core/annotations_impl/di", "angular2/src/core/compiler/view", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/view_container_ref", "angular2/src/core/compiler/element_ref", "angular2/src/core/compiler/view_ref", "angular2/src/core/annotations_impl/annotations", "angular2/change_detection", "angular2/src/core/compiler/query_list", "angular2/src/reflection/reflection"], function($__export) { + "use strict"; + var __moduleName = "angular2/src/core/compiler/element_injector"; + var isPresent, isBlank, Type, int, BaseException, + stringify, EventEmitter, ObservableWrapper, Math, List, ListWrapper, MapWrapper, + StringMapWrapper, Injector, Key, Dependency, @@ -28352,6 +23616,7 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt DirectiveBinding, PreBuiltObjects, EventEmitterAccessor, + HostActionAccessor, ProtoElementInjector, ElementInjector, OutOfBoundsAccess, @@ -28359,13 +23624,12 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt QueryRef; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { isPresent = $__m.isPresent; isBlank = $__m.isBlank; Type = $__m.Type; int = $__m.int; BaseException = $__m.BaseException; + stringify = $__m.stringify; }, function($__m) { EventEmitter = $__m.EventEmitter; ObservableWrapper = $__m.ObservableWrapper; @@ -28375,6 +23639,7 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt List = $__m.List; ListWrapper = $__m.ListWrapper; MapWrapper = $__m.MapWrapper; + StringMapWrapper = $__m.StringMapWrapper; }, function($__m) { Injector = $__m.Injector; Key = $__m.Key; @@ -28431,12 +23696,11 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return ($traceurRuntime.createClass)(StaticKeys, {}, {instance: function() { if (isBlank(_staticKeys)) _staticKeys = new StaticKeys(); - return assert.returnType((_staticKeys), StaticKeys); + return _staticKeys; }}); }()); TreeNode = (function() { function TreeNode(parent) { - assert.argumentTypes(parent, TreeNode); this._head = null; this._tail = null; this._next = null; @@ -28476,7 +23740,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt throw new BaseException('node not reachable through parent.'); }, addChild: function(child) { - assert.argumentTypes(child, TreeNode); if (isPresent(this._tail)) { this._tail._next = child; this._tail = child; @@ -28488,7 +23751,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt this._assertConsistency(); }, addChildAfter: function(child, prevSibling) { - assert.argumentTypes(child, TreeNode, prevSibling, TreeNode); this._assertConsistency(); if (isBlank(prevSibling)) { var prevHead = this._head; @@ -28560,7 +23822,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt }}); DirectiveDependency = (function($__super) { function DirectiveDependency(key, asPromise, lazy, optional, properties, depth, attributeName, queryDirective) { - assert.argumentTypes(key, Key, asPromise, assert.type.boolean, lazy, assert.type.boolean, optional, assert.type.boolean, properties, List, depth, int, attributeName, assert.type.string, queryDirective, assert.type.any); $traceurRuntime.superConstructor(DirectiveDependency).call(this, key, asPromise, lazy, optional, properties); this.depth = depth; this.attributeName = attributeName; @@ -28577,27 +23838,26 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt throw new BaseException('A directive injectable can contain only one of the following @Attribute or @Query.'); }}, { createFrom: function(d) { - assert.argumentTypes(d, Dependency); - return assert.returnType((new DirectiveDependency(d.key, d.asPromise, d.lazy, d.optional, d.properties, DirectiveDependency._depth(d.properties), DirectiveDependency._attributeName(d.properties), DirectiveDependency._query(d.properties))), Dependency); + return new DirectiveDependency(d.key, d.asPromise, d.lazy, d.optional, d.properties, DirectiveDependency._depth(d.properties), DirectiveDependency._attributeName(d.properties), DirectiveDependency._query(d.properties)); }, _depth: function(properties) { if (properties.length == 0) - return assert.returnType((0), int); + return 0; if (ListWrapper.any(properties, (function(p) { return p instanceof Parent; }))) - return assert.returnType((1), int); + return 1; if (ListWrapper.any(properties, (function(p) { return p instanceof Ancestor; }))) - return assert.returnType((MAX_DEPTH), int); - return assert.returnType((0), int); + return MAX_DEPTH; + return 0; }, _attributeName: function(properties) { var p = ListWrapper.find(properties, (function(p) { return p instanceof Attribute; })); - return assert.returnType((isPresent(p) ? p.attributeName : null), assert.type.string); + return isPresent(p) ? p.attributeName : null; }, _query: function(properties) { var p = ListWrapper.find(properties, (function(p) { @@ -28616,7 +23876,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt }}); DirectiveBinding = (function($__super) { function DirectiveBinding(key, factory, dependencies, providedAsPromise, annotation) { - assert.argumentTypes(key, Key, factory, Function, dependencies, List, providedAsPromise, assert.type.boolean, annotation, Directive); $traceurRuntime.superConstructor(DirectiveBinding).call(this, key, factory, dependencies, providedAsPromise); this.callOnDestroy = isPresent(annotation) && annotation.hasLifecycleHook(onDestroy); this.callOnChange = isPresent(annotation) && annotation.hasLifecycleHook(onChange); @@ -28631,11 +23890,14 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return this.key.displayName; }, get eventEmitters() { - return assert.returnType((isPresent(this.annotation) && isPresent(this.annotation.events) ? this.annotation.events : []), assert.genericType(List, assert.type.string)); + return isPresent(this.annotation) && isPresent(this.annotation.events) ? this.annotation.events : []; + }, + get hostActions() { + return isPresent(this.annotation) && isPresent(this.annotation.hostActions) ? this.annotation.hostActions : {}; }, get changeDetection() { if (this.annotation instanceof Component) { - var c = assert.type(this.annotation, Component); + var c = this.annotation; return c.changeDetection; } else { return null; @@ -28643,15 +23905,13 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt } }, { createFromBinding: function(b, annotation) { - assert.argumentTypes(b, Binding, annotation, Directive); var rb = b.resolve(); var deps = ListWrapper.map(rb.dependencies, DirectiveDependency.createFrom); - return assert.returnType((new DirectiveBinding(rb.key, rb.factory, deps, rb.providedAsPromise, annotation)), DirectiveBinding); + return new DirectiveBinding(rb.key, rb.factory, deps, rb.providedAsPromise, annotation); }, createFromType: function(type, annotation) { - assert.argumentTypes(type, Type, annotation, Directive); var binding = new Binding(type, {toClass: type}); - return assert.returnType((DirectiveBinding.createFromBinding(binding, annotation)), DirectiveBinding); + return DirectiveBinding.createFromBinding(binding, annotation); } }, $__super); }(ResolvedBinding)); @@ -28667,7 +23927,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt }}); PreBuiltObjects = (function() { function PreBuiltObjects(viewManager, view, protoView) { - assert.argumentTypes(viewManager, avmModule.AppViewManager, view, viewModule.AppView, protoView, viewModule.AppProtoView); this.viewManager = viewManager; this.view = view; this.protoView = protoView; @@ -28680,7 +23939,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt }}); EventEmitterAccessor = (function() { function EventEmitterAccessor(eventName, getter) { - assert.argumentTypes(eventName, assert.type.string, getter, Function); this.eventName = eventName; this.getter = getter; } @@ -28698,11 +23956,29 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt Object.defineProperty(EventEmitterAccessor.prototype.subscribe, "parameters", {get: function() { return [[viewModule.AppView], [assert.type.number], [Object]]; }}); + HostActionAccessor = (function() { + function HostActionAccessor(actionExpression, getter) { + this.actionExpression = actionExpression; + this.getter = getter; + } + return ($traceurRuntime.createClass)(HostActionAccessor, {subscribe: function(view, boundElementIndex, directive) { + var $__0 = this; + var eventEmitter = this.getter(directive); + return ObservableWrapper.subscribe(eventEmitter, (function(actionObj) { + return view.callAction(boundElementIndex, $__0.actionExpression, actionObj); + })); + }}, {}); + }()); + Object.defineProperty(HostActionAccessor, "parameters", {get: function() { + return [[assert.type.string], [Function]]; + }}); + Object.defineProperty(HostActionAccessor.prototype.subscribe, "parameters", {get: function() { + return [[viewModule.AppView], [assert.type.number], [Object]]; + }}); ProtoElementInjector = (function() { function ProtoElementInjector(parent, index, bindings) { var firstBindingIsComponent = arguments[3] !== (void 0) ? arguments[3] : false; var distanceToParent = arguments[4] !== (void 0) ? arguments[4] : 0; - assert.argumentTypes(parent, ProtoElementInjector, index, int, bindings, List, firstBindingIsComponent, assert.type.boolean, distanceToParent, assert.type.number); this.parent = parent; this.index = index; this.distanceToParent = distanceToParent; @@ -28732,55 +24008,66 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt this.numberOfDirectives = bindings.length; var length = bindings.length; this.eventEmitterAccessors = ListWrapper.createFixedSize(length); + this.hostActionAccessors = ListWrapper.createFixedSize(length); if (length > 0) { this._binding0 = this._createBinding(bindings[0]); this._keyId0 = this._binding0.key.id; this.eventEmitterAccessors[0] = this._createEventEmitterAccessors(this._binding0); + this.hostActionAccessors[0] = this._createHostActionAccessors(this._binding0); } if (length > 1) { this._binding1 = this._createBinding(bindings[1]); this._keyId1 = this._binding1.key.id; this.eventEmitterAccessors[1] = this._createEventEmitterAccessors(this._binding1); + this.hostActionAccessors[1] = this._createHostActionAccessors(this._binding1); } if (length > 2) { this._binding2 = this._createBinding(bindings[2]); this._keyId2 = this._binding2.key.id; this.eventEmitterAccessors[2] = this._createEventEmitterAccessors(this._binding2); + this.hostActionAccessors[2] = this._createHostActionAccessors(this._binding2); } if (length > 3) { this._binding3 = this._createBinding(bindings[3]); this._keyId3 = this._binding3.key.id; this.eventEmitterAccessors[3] = this._createEventEmitterAccessors(this._binding3); + this.hostActionAccessors[3] = this._createHostActionAccessors(this._binding3); } if (length > 4) { this._binding4 = this._createBinding(bindings[4]); this._keyId4 = this._binding4.key.id; this.eventEmitterAccessors[4] = this._createEventEmitterAccessors(this._binding4); + this.hostActionAccessors[4] = this._createHostActionAccessors(this._binding4); } if (length > 5) { this._binding5 = this._createBinding(bindings[5]); this._keyId5 = this._binding5.key.id; this.eventEmitterAccessors[5] = this._createEventEmitterAccessors(this._binding5); + this.hostActionAccessors[5] = this._createHostActionAccessors(this._binding5); } if (length > 6) { this._binding6 = this._createBinding(bindings[6]); this._keyId6 = this._binding6.key.id; this.eventEmitterAccessors[6] = this._createEventEmitterAccessors(this._binding6); + this.hostActionAccessors[6] = this._createHostActionAccessors(this._binding6); } if (length > 7) { this._binding7 = this._createBinding(bindings[7]); this._keyId7 = this._binding7.key.id; this.eventEmitterAccessors[7] = this._createEventEmitterAccessors(this._binding7); + this.hostActionAccessors[7] = this._createHostActionAccessors(this._binding7); } if (length > 8) { this._binding8 = this._createBinding(bindings[8]); this._keyId8 = this._binding8.key.id; this.eventEmitterAccessors[8] = this._createEventEmitterAccessors(this._binding8); + this.hostActionAccessors[8] = this._createHostActionAccessors(this._binding8); } if (length > 9) { this._binding9 = this._createBinding(bindings[9]); this._keyId9 = this._binding9.key.id; this.eventEmitterAccessors[9] = this._createEventEmitterAccessors(this._binding9); + this.hostActionAccessors[9] = this._createHostActionAccessors(this._binding9); } if (length > 10) { throw 'Maximum number of directives per element has been reached.'; @@ -28792,12 +24079,18 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return new EventEmitterAccessor(eventName, reflector.getter(eventName)); })); }, + _createHostActionAccessors: function(b) { + var res = []; + StringMapWrapper.forEach(b.hostActions, (function(actionExpression, actionName) { + ListWrapper.push(res, new HostActionAccessor(actionExpression, reflector.getter(actionName))); + })); + return res; + }, instantiate: function(parent) { - assert.argumentTypes(parent, ElementInjector); - return assert.returnType((new ElementInjector(this, parent)), ElementInjector); + return new ElementInjector(this, parent); }, directParent: function() { - return assert.returnType((this.distanceToParent < 2 ? this.parent : null), ProtoElementInjector); + return this.distanceToParent < 2 ? this.parent : null; }, _createBinding: function(bindingOrType) { if (bindingOrType instanceof DirectiveBinding) { @@ -28808,10 +24101,9 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt } }, get hasBindings() { - return assert.returnType((isPresent(this._binding0)), assert.type.boolean); + return isPresent(this._binding0); }, getDirectiveBindingAtIndex: function(index) { - assert.argumentTypes(index, int); if (index == 0) return this._binding0; if (index == 1) @@ -28843,6 +24135,9 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt Object.defineProperty(ProtoElementInjector.prototype._createEventEmitterAccessors, "parameters", {get: function() { return [[DirectiveBinding]]; }}); + Object.defineProperty(ProtoElementInjector.prototype._createHostActionAccessors, "parameters", {get: function() { + return [[DirectiveBinding]]; + }}); Object.defineProperty(ProtoElementInjector.prototype.instantiate, "parameters", {get: function() { return [[ElementInjector]]; }}); @@ -28851,7 +24146,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt }}); ElementInjector = (function($__super) { function ElementInjector(proto, parent) { - assert.argumentTypes(proto, ProtoElementInjector, parent, ElementInjector); $traceurRuntime.superConstructor(ElementInjector).call(this, parent); this._proto = proto; this._preBuiltObjects = null; @@ -28925,8 +24219,12 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt this._dynamicallyCreatedComponentBinding = null; this._constructionCounter = 0; }, - instantiateDirectives: function(lightDomAppInjector, host, shadowDomAppInjector, preBuiltObjects) { - assert.argumentTypes(lightDomAppInjector, Injector, host, ElementInjector, shadowDomAppInjector, Injector, preBuiltObjects, PreBuiltObjects); + instantiateDirectives: function(lightDomAppInjector, host, preBuiltObjects) { + var $__0 = this; + var shadowDomAppInjector = null; + if (this._proto._binding0IsComponent) { + shadowDomAppInjector = this._createShadowDomAppInjector(this._proto._binding0, lightDomAppInjector); + } this._host = host; this._checkShadowDomAppInjector(shadowDomAppInjector); this._preBuiltObjects = preBuiltObjects; @@ -28935,6 +24233,15 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt var p = this._proto; if (isPresent(p._keyId0)) this._getDirectiveByKeyId(p._keyId0); + if (isPresent(shadowDomAppInjector)) { + var componentAnnotation = this._proto._binding0.annotation; + var publishAs = componentAnnotation.publishAs; + if (isPresent(publishAs) && publishAs.length > 0) { + this._shadowDomAppInjector = shadowDomAppInjector.resolveAndCreateChild(ListWrapper.map(publishAs, (function(token) { + return bind(token).toValue($__0.getComponent()); + }))); + } + } if (isPresent(p._keyId1)) this._getDirectiveByKeyId(p._keyId1); if (isPresent(p._keyId2)) @@ -28954,15 +24261,23 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt if (isPresent(p._keyId9)) this._getDirectiveByKeyId(p._keyId9); }, - dynamicallyCreateComponent: function(directiveBinding, injector) { - assert.argumentTypes(directiveBinding, assert.type.any, injector, Injector); - this._shadowDomAppInjector = injector; - this._dynamicallyCreatedComponentBinding = directiveBinding; + _createShadowDomAppInjector: function(componentDirective, appInjector) { + var shadowDomAppInjector = null; + var injectables = componentDirective.resolvedInjectables; + if (isPresent(injectables)) { + shadowDomAppInjector = appInjector.createChildFromResolved(injectables); + } else { + shadowDomAppInjector = appInjector; + } + return shadowDomAppInjector; + }, + dynamicallyCreateComponent: function(componentDirective, parentInjector) { + this._shadowDomAppInjector = this._createShadowDomAppInjector(componentDirective, parentInjector); + this._dynamicallyCreatedComponentBinding = componentDirective; this._dynamicallyCreatedComponent = this._new(this._dynamicallyCreatedComponentBinding); return this._dynamicallyCreatedComponent; }, _checkShadowDomAppInjector: function(shadowDomAppInjector) { - assert.argumentTypes(shadowDomAppInjector, Injector); if (this._proto._binding0IsComponent && isBlank(shadowDomAppInjector)) { throw new BaseException('A shadowDomAppInjector is required as this ElementInjector contains a component'); } else if (!this._proto._binding0IsComponent && isPresent(shadowDomAppInjector)) { @@ -28979,12 +24294,14 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return isPresent(this._dynamicallyCreatedComponentBinding) && Key.get(token) === this._dynamicallyCreatedComponentBinding.key; }, hasDirective: function(type) { - assert.argumentTypes(type, Type); - return assert.returnType((this._getDirectiveByKeyId(Key.get(type).id) !== _undefined), assert.type.boolean); + return this._getDirectiveByKeyId(Key.get(type).id) !== _undefined; }, getEventEmitterAccessors: function() { return this._proto.eventEmitterAccessors; }, + getHostActionAccessors: function() { + return this._proto.hostActionAccessors; + }, getComponent: function() { if (this._proto._binding0IsComponent) { return this._obj0; @@ -29002,18 +24319,15 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return this._dynamicallyCreatedComponent; }, directParent: function() { - return assert.returnType((this._proto.distanceToParent < 2 ? this.parent : null), ElementInjector); + return this._proto.distanceToParent < 2 ? this.parent : null; }, _isComponentKey: function(key) { - assert.argumentTypes(key, Key); return this._proto._binding0IsComponent && key.id === this._proto._keyId0; }, _isDynamicallyLoadedComponentKey: function(key) { - assert.argumentTypes(key, Key); return isPresent(this._dynamicallyCreatedComponentBinding) && key.id === this._dynamicallyCreatedComponentBinding.key.id; }, _new: function(binding) { - assert.argumentTypes(binding, ResolvedBinding); if (this._constructionCounter++ > _MAX_DIRECTIVE_CONSTRUCTION_COUNTER) { throw new CyclicDependencyError(binding.key); } @@ -29088,7 +24402,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return obj; }, _getByDependency: function(dep, requestor) { - assert.argumentTypes(dep, DirectiveDependency, requestor, Key); if (isPresent(dep.attributeName)) return this._buildAttribute(dep); if (isPresent(dep.queryDirective)) @@ -29114,13 +24427,12 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt _buildAttribute: function(dep) { var attributes = this._proto.attributes; if (isPresent(attributes) && MapWrapper.contains(attributes, dep.attributeName)) { - return assert.returnType((MapWrapper.get(attributes, dep.attributeName)), assert.type.string); + return MapWrapper.get(attributes, dep.attributeName); } else { - return assert.returnType((null), assert.type.string); + return null; } }, _buildQueriesForDeps: function(deps) { - assert.argumentTypes(deps, assert.genericType(List, DirectiveDependency)); for (var i = 0; i < deps.length; i++) { var dep = deps[i]; if (isPresent(dep.queryDirective)) { @@ -29151,7 +24463,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt } }, _inheritQueries: function(parent) { - assert.argumentTypes(parent, ElementInjector); if (isBlank(parent)) return ; if (isPresent(parent._query0)) { @@ -29212,12 +24523,10 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt throw new BaseException(("Cannot find query for directive " + token + ".")); }, link: function(parent) { - assert.argumentTypes(parent, ElementInjector); parent.addChild(this); this._addParentQueries(); }, linkAfter: function(parent, prevSibling) { - assert.argumentTypes(parent, ElementInjector, prevSibling, ElementInjector); parent.addChildAfter(this, prevSibling); this._addParentQueries(); }, @@ -29255,7 +24564,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt })); }, _pruneQueryFromTree: function(query) { - assert.argumentTypes(query, QueryRef); this._removeQueryRef(query); var child = this._head; while (isPresent(child)) { @@ -29264,7 +24572,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt } }, _addQueryToTree: function(query) { - assert.argumentTypes(query, QueryRef); this._assignQueryRef(query); var child = this._head; while (isPresent(child)) { @@ -29273,7 +24580,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt } }, _assignQueryRef: function(query) { - assert.argumentTypes(query, QueryRef); if (isBlank(this._query0)) { this._query0 = query; return ; @@ -29287,7 +24593,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt throw new QueryError(); }, _removeQueryRef: function(query) { - assert.argumentTypes(query, QueryRef); if (this._query0 == query) this._query0 = null; if (this._query1 == query) @@ -29296,7 +24601,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt this._query2 = null; }, _getByKey: function(key, depth, optional, requestor) { - assert.argumentTypes(key, Key, depth, assert.type.number, optional, assert.type.boolean, requestor, Key); var ei = this; if (!this._shouldIncludeSelf(depth)) { depth -= ei._proto.distanceToParent; @@ -29323,7 +24627,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt } }, _appInjector: function(requestor) { - assert.argumentTypes(requestor, Key); if (isPresent(requestor) && (this._isComponentKey(requestor) || this._isDynamicallyLoadedComponentKey(requestor))) { return this._shadowDomAppInjector; } else { @@ -29331,18 +24634,15 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt } }, _shouldIncludeSelf: function(depth) { - assert.argumentTypes(depth, int); return depth === 0; }, _getPreBuiltObjectByKeyId: function(keyId) { - assert.argumentTypes(keyId, int); var staticKeys = StaticKeys.instance(); if (keyId === staticKeys.viewManagerId) - return this._preBuiltObjects.viewManagerId; + return this._preBuiltObjects.viewManager; return _undefined; }, _getDirectiveByKeyId: function(keyId) { - assert.argumentTypes(keyId, int); var p = this._proto; if (p._keyId0 === keyId) { if (isBlank(this._obj0)) { @@ -29407,7 +24707,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return _undefined; }, getDirectiveAtIndex: function(index) { - assert.argumentTypes(index, int); if (index == 0) return this._obj0; if (index == 1) @@ -29461,10 +24760,13 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return [[ProtoElementInjector], [ElementInjector]]; }}); Object.defineProperty(ElementInjector.prototype.instantiateDirectives, "parameters", {get: function() { - return [[Injector], [ElementInjector], [Injector], [PreBuiltObjects]]; + return [[Injector], [ElementInjector], [PreBuiltObjects]]; + }}); + Object.defineProperty(ElementInjector.prototype._createShadowDomAppInjector, "parameters", {get: function() { + return [[DirectiveBinding], [Injector]]; }}); Object.defineProperty(ElementInjector.prototype.dynamicallyCreateComponent, "parameters", {get: function() { - return [[], [Injector]]; + return [[DirectiveBinding], [Injector]]; }}); Object.defineProperty(ElementInjector.prototype._checkShadowDomAppInjector, "parameters", {get: function() { return [[Injector]]; @@ -29534,7 +24836,7 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return ($traceurRuntime.createClass)(OutOfBoundsAccess, {toString: function() { return this.message; }}, {}, $__super); - }(Error)); + }(BaseException)); QueryError = (function($__super) { function QueryError() { $traceurRuntime.superConstructor(QueryError).call(this); @@ -29543,10 +24845,9 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt return ($traceurRuntime.createClass)(QueryError, {toString: function() { return this.message; }}, {}, $__super); - }(Error)); + }(BaseException)); QueryRef = (function() { function QueryRef(directive, list, originator) { - assert.argumentTypes(directive, assert.type.any, list, QueryList, originator, ElementInjector); this.directive = directive; this.list = list; this.originator = originator; @@ -29558,7 +24859,6 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt this.list.reset(aggregator); }, visit: function(inj, aggregator) { - assert.argumentTypes(inj, ElementInjector, aggregator, assert.type.any); if (isBlank(inj)) return ; if (inj.hasDirective(this.directive)) { @@ -29582,11 +24882,10 @@ System.register("angular2/src/core/compiler/element_injector", ["rtts_assert/rtt }; }); -System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", "angular2/src/facade/collection", "angular2/change_detection", "angular2/src/core/compiler/element_injector", "angular2/src/core/compiler/element_binder", "angular2/src/reflection/types", "angular2/src/facade/lang", "angular2/src/render/api"], function($__export) { +System.register("angular2/src/core/compiler/view", ["angular2/src/facade/collection", "angular2/change_detection", "angular2/src/core/compiler/element_injector", "angular2/src/core/compiler/element_binder", "angular2/src/facade/lang", "angular2/src/render/api"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/view"; - var assert, - ListWrapper, + var ListWrapper, MapWrapper, Map, StringMapWrapper, @@ -29606,7 +24905,6 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " PreBuiltObjects, DirectiveBinding, ElementBinder, - SetterFn, IMPLEMENTS, int, isPresent, @@ -29618,8 +24916,6 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " AppProtoView; return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { ListWrapper = $__m.ListWrapper; MapWrapper = $__m.MapWrapper; Map = $__m.Map; @@ -29643,8 +24939,6 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " DirectiveBinding = $__m.DirectiveBinding; }, function($__m) { ElementBinder = $__m.ElementBinder; - }, function($__m) { - SetterFn = $__m.SetterFn; }, function($__m) { IMPLEMENTS = $__m.IMPLEMENTS; int = $__m.int; @@ -29664,7 +24958,6 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " $__export("AppViewContainer", AppViewContainer); AppView = (function() { function AppView(renderer, proto, protoLocals) { - assert.argumentTypes(renderer, renderApi.Renderer, proto, AppProtoView, protoLocals, Map); this.render = null; this.proto = proto; this.changeDetector = null; @@ -29676,11 +24969,10 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " this.context = null; this.locals = new Locals(null, MapWrapper.clone(protoLocals)); this.renderer = renderer; - this.imperativeHostViews = []; + this.inPlaceHostViews = []; } return ($traceurRuntime.createClass)(AppView, { init: function(changeDetector, elementInjectors, rootElementInjectors, preBuiltObjects, componentChildViews) { - assert.argumentTypes(changeDetector, ChangeDetector, elementInjectors, List, rootElementInjectors, List, preBuiltObjects, List, componentChildViews, List); this.changeDetector = changeDetector; this.elementInjectors = elementInjectors; this.rootElementInjectors = rootElementInjectors; @@ -29688,7 +24980,6 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " this.componentChildViews = componentChildViews; }, setLocal: function(contextName, value) { - assert.argumentTypes(contextName, assert.type.string, value, assert.type.any); if (!this.hydrated()) throw new BaseException('Cannot set locals on dehydrated view.'); if (!MapWrapper.contains(this.proto.variableBindings, contextName)) { @@ -29698,16 +24989,14 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " this.locals.set(templateName, value); }, hydrated: function() { - return assert.returnType((isPresent(this.context)), assert.type.boolean); + return isPresent(this.context); }, triggerEventHandlers: function(eventName, eventObj, binderIndex) { - assert.argumentTypes(eventName, assert.type.string, eventObj, assert.type.any, binderIndex, int); var locals = MapWrapper.create(); MapWrapper.set(locals, '$event', eventObj); this.dispatchEvent(binderIndex, eventName, locals); }, notifyOnBinding: function(b, currentValue) { - assert.argumentTypes(b, BindingRecord, currentValue, assert.type.any); if (b.isElement()) { this.renderer.setElementProperty(this.render, b.elementIndex, b.propertyName, currentValue); } else { @@ -29715,26 +25004,26 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " } }, getDirectiveFor: function(directive) { - assert.argumentTypes(directive, DirectiveIndex); var elementInjector = this.elementInjectors[directive.elementIndex]; return elementInjector.getDirectiveAtIndex(directive.directiveIndex); }, getDetectorFor: function(directive) { - assert.argumentTypes(directive, DirectiveIndex); var childView = this.componentChildViews[directive.elementIndex]; return isPresent(childView) ? childView.changeDetector : null; }, + callAction: function(elementIndex, actionExpression, action) { + this.renderer.callAction(this.render, elementIndex, actionExpression, action); + }, dispatchEvent: function(elementIndex, eventName, locals) { var $__0 = this; - assert.argumentTypes(elementIndex, assert.type.number, eventName, assert.type.string, locals, assert.genericType(Map, assert.type.string, assert.type.any)); var allowDefaultBehavior = true; if (this.hydrated()) { var elBinder = this.proto.elementBinders[elementIndex]; if (isBlank(elBinder.hostListeners)) - return assert.returnType((allowDefaultBehavior), assert.type.boolean); + return allowDefaultBehavior; var eventMap = elBinder.hostListeners[eventName]; if (isBlank(eventMap)) - return assert.returnType((allowDefaultBehavior), assert.type.boolean); + return allowDefaultBehavior; MapWrapper.forEach(eventMap, (function(expr, directiveIndex) { var context; if (directiveIndex === -1) { @@ -29748,7 +25037,7 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " } })); } - return assert.returnType((allowDefaultBehavior), assert.type.boolean); + return allowDefaultBehavior; } }, {}); }()); @@ -29777,84 +25066,31 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " Object.defineProperty(AppView.prototype.getDetectorFor, "parameters", {get: function() { return [[DirectiveIndex]]; }}); + Object.defineProperty(AppView.prototype.callAction, "parameters", {get: function() { + return [[assert.type.number], [assert.type.string], [Object]]; + }}); Object.defineProperty(AppView.prototype.dispatchEvent, "parameters", {get: function() { return [[assert.type.number], [assert.type.string], [assert.genericType(Map, assert.type.string, assert.type.any)]]; }}); AppProtoView = (function() { - function AppProtoView(render, protoChangeDetector) { - assert.argumentTypes(render, renderApi.RenderProtoViewRef, protoChangeDetector, ProtoChangeDetector); + function AppProtoView(render, protoChangeDetector, variableBindings, protoLocals, variableNames) { this.render = render; this.elementBinders = []; - this.variableBindings = MapWrapper.create(); - this.protoLocals = MapWrapper.create(); + this.variableBindings = variableBindings; + this.protoLocals = protoLocals; + this.variableNames = variableNames; this.protoChangeDetector = protoChangeDetector; - this.parentProtoView = null; - this.textNodesWithBindingCount = 0; - this.bindings = []; - this._directiveRecordsMap = MapWrapper.create(); - this._variableBindings = null; - this._directiveRecords = null; } return ($traceurRuntime.createClass)(AppProtoView, { - getVariableBindings: function() { - var $__0 = this; - if (isPresent(this._variableBindings)) { - return assert.returnType((this._variableBindings), List); - } - this._variableBindings = isPresent(this.parentProtoView) ? ListWrapper.clone(this.parentProtoView.getVariableBindings()) : []; - MapWrapper.forEach(this.protoLocals, (function(v, local) { - ListWrapper.push($__0._variableBindings, local); - })); - return assert.returnType((this._variableBindings), List); - }, - getdirectiveRecords: function() { - if (isPresent(this._directiveRecords)) { - return assert.returnType((this._directiveRecords), List); - } - this._directiveRecords = []; - for (var injectorIndex = 0; injectorIndex < this.elementBinders.length; ++injectorIndex) { - var pei = this.elementBinders[injectorIndex].protoElementInjector; - if (isPresent(pei)) { - for (var directiveIndex = 0; directiveIndex < pei.numberOfDirectives; ++directiveIndex) { - ListWrapper.push(this._directiveRecords, this._getDirectiveRecord(injectorIndex, directiveIndex)); - } - } - } - return assert.returnType((this._directiveRecords), List); - }, - bindVariable: function(contextName, templateName) { - assert.argumentTypes(contextName, assert.type.string, templateName, assert.type.string); - MapWrapper.set(this.variableBindings, contextName, templateName); - MapWrapper.set(this.protoLocals, templateName, null); - }, bindElement: function(parent, distanceToParent, protoElementInjector) { var componentDirective = arguments[3] !== (void 0) ? arguments[3] : null; - assert.argumentTypes(parent, ElementBinder, distanceToParent, int, protoElementInjector, ProtoElementInjector, componentDirective, DirectiveBinding); var elBinder = new ElementBinder(this.elementBinders.length, parent, distanceToParent, protoElementInjector, componentDirective); ListWrapper.push(this.elementBinders, elBinder); - return assert.returnType((elBinder), ElementBinder); - }, - bindTextNode: function(expression) { - assert.argumentTypes(expression, AST); - var textNodeIndex = this.textNodesWithBindingCount++; - var b = BindingRecord.createForTextNode(expression, textNodeIndex); - ListWrapper.push(this.bindings, b); - }, - bindElementProperty: function(expression, setterName) { - assert.argumentTypes(expression, AST, setterName, assert.type.string); - var elementIndex = this.elementBinders.length - 1; - var b = BindingRecord.createForElement(expression, elementIndex, setterName); - ListWrapper.push(this.bindings, b); - }, - bindHostElementProperty: function(expression, setterName, directiveIndex) { - assert.argumentTypes(expression, AST, setterName, assert.type.string, directiveIndex, DirectiveIndex); - var b = BindingRecord.createForHostProperty(directiveIndex, expression, setterName); - ListWrapper.push(this.bindings, b); - }, - bindEvent: function(eventBindings) { - var directiveIndex = arguments[1] !== (void 0) ? arguments[1] : -1; - assert.argumentTypes(eventBindings, assert.genericType(List, renderApi.EventBinding), directiveIndex, int); - var elBinder = this.elementBinders[this.elementBinders.length - 1]; + return elBinder; + }, + bindEvent: function(eventBindings, boundElementIndex) { + var directiveIndex = arguments[2] !== (void 0) ? arguments[2] : -1; + var elBinder = this.elementBinders[boundElementIndex]; var events = elBinder.hostListeners; if (isBlank(events)) { events = StringMapWrapper.create(); @@ -29870,65 +25106,28 @@ System.register("angular2/src/core/compiler/view", ["rtts_assert/rtts_assert", " } MapWrapper.set(event, directiveIndex, eventBinding.source); } - }, - bindDirectiveProperty: function(directiveIndex, expression, setterName, setter) { - assert.argumentTypes(directiveIndex, assert.type.number, expression, AST, setterName, assert.type.string, setter, SetterFn); - var elementIndex = this.elementBinders.length - 1; - var directiveRecord = this._getDirectiveRecord(elementIndex, directiveIndex); - var b = BindingRecord.createForDirective(expression, setterName, setter, directiveRecord); - ListWrapper.push(this.bindings, b); - }, - _getDirectiveRecord: function(elementInjectorIndex, directiveIndex) { - assert.argumentTypes(elementInjectorIndex, assert.type.number, directiveIndex, assert.type.number); - var id = elementInjectorIndex * 100 + directiveIndex; - var protoElementInjector = this.elementBinders[elementInjectorIndex].protoElementInjector; - if (!MapWrapper.contains(this._directiveRecordsMap, id)) { - var binding = protoElementInjector.getDirectiveBindingAtIndex(directiveIndex); - var changeDetection = binding.changeDetection; - MapWrapper.set(this._directiveRecordsMap, id, new DirectiveRecord(new DirectiveIndex(elementInjectorIndex, directiveIndex), binding.callOnAllChangesDone, binding.callOnChange, changeDetection)); - } - return assert.returnType((MapWrapper.get(this._directiveRecordsMap, id)), DirectiveRecord); } }, {}); }()); $__export("AppProtoView", AppProtoView); Object.defineProperty(AppProtoView, "parameters", {get: function() { - return [[renderApi.RenderProtoViewRef], [ProtoChangeDetector]]; - }}); - Object.defineProperty(AppProtoView.prototype.bindVariable, "parameters", {get: function() { - return [[assert.type.string], [assert.type.string]]; + return [[renderApi.RenderProtoViewRef], [ProtoChangeDetector], [Map], [Map], [List]]; }}); Object.defineProperty(AppProtoView.prototype.bindElement, "parameters", {get: function() { return [[ElementBinder], [int], [ProtoElementInjector], [DirectiveBinding]]; }}); - Object.defineProperty(AppProtoView.prototype.bindTextNode, "parameters", {get: function() { - return [[AST]]; - }}); - Object.defineProperty(AppProtoView.prototype.bindElementProperty, "parameters", {get: function() { - return [[AST], [assert.type.string]]; - }}); - Object.defineProperty(AppProtoView.prototype.bindHostElementProperty, "parameters", {get: function() { - return [[AST], [assert.type.string], [DirectiveIndex]]; - }}); Object.defineProperty(AppProtoView.prototype.bindEvent, "parameters", {get: function() { - return [[assert.genericType(List, renderApi.EventBinding)], [int]]; - }}); - Object.defineProperty(AppProtoView.prototype.bindDirectiveProperty, "parameters", {get: function() { - return [[assert.type.number], [AST], [assert.type.string], [SetterFn]]; - }}); - Object.defineProperty(AppProtoView.prototype._getDirectiveRecord, "parameters", {get: function() { - return [[assert.type.number], [assert.type.number]]; + return [[assert.genericType(List, renderApi.EventBinding)], [assert.type.number], [int]]; }}); } }; }); -System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/collection", "angular2/src/core/compiler/directive_metadata_reader", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view", "angular2/src/core/compiler/view_ref", "angular2/src/core/compiler/element_injector", "angular2/src/core/compiler/template_resolver", "angular2/src/core/annotations_impl/view", "angular2/src/core/compiler/component_url_mapper", "angular2/src/core/compiler/proto_view_factory", "angular2/src/services/url_resolver", "angular2/src/render/api"], function($__export) { +System.register("angular2/src/core/compiler/compiler", ["angular2/di", "angular2/src/di/annotations_impl", "angular2/src/facade/lang", "angular2/src/facade/async", "angular2/src/facade/collection", "angular2/src/core/compiler/directive_metadata_reader", "angular2/src/core/annotations_impl/annotations", "angular2/src/core/compiler/view", "angular2/src/core/compiler/view_ref", "angular2/src/core/compiler/element_injector", "angular2/src/core/compiler/template_resolver", "angular2/src/core/annotations_impl/view", "angular2/src/core/compiler/component_url_mapper", "angular2/src/core/compiler/proto_view_factory", "angular2/src/services/url_resolver", "angular2/src/render/api"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/compiler/compiler"; - var assert, + var Binding, Injectable, - Binding, Type, isBlank, isPresent, @@ -29943,7 +25142,7 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert MapWrapper, DirectiveMetadataReader, Component, - Decorator, + Directive, AppProtoView, ProtoViewRef, DirectiveBinding, @@ -29957,10 +25156,9 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert Compiler; return { setters: [function($__m) { - assert = $__m.assert; + Binding = $__m.Binding; }, function($__m) { Injectable = $__m.Injectable; - Binding = $__m.Binding; }, function($__m) { Type = $__m.Type; isBlank = $__m.isBlank; @@ -29980,7 +25178,7 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert DirectiveMetadataReader = $__m.DirectiveMetadataReader; }, function($__m) { Component = $__m.Component; - Decorator = $__m.Decorator; + Directive = $__m.Directive; }, function($__m) { AppProtoView = $__m.AppProtoView; }, function($__m) { @@ -30007,13 +25205,11 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert } return ($traceurRuntime.createClass)(CompilerCache, { set: function(component, protoView) { - assert.argumentTypes(component, Type, protoView, AppProtoView); MapWrapper.set(this._cache, component, protoView); }, get: function(component) { - assert.argumentTypes(component, Type); var result = MapWrapper.get(this._cache, component); - return assert.returnType((normalizeBlank(result)), AppProtoView); + return normalizeBlank(result); }, clear: function() { MapWrapper.clear(this._cache); @@ -30031,8 +25227,7 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert return [[Type]]; }}); Compiler = (function() { - function Compiler(reader, cache, templateResolver, componentUrlMapper, urlResolver, renderer, protoViewFactory) { - assert.argumentTypes(reader, DirectiveMetadataReader, cache, CompilerCache, templateResolver, TemplateResolver, componentUrlMapper, ComponentUrlMapper, urlResolver, UrlResolver, renderer, renderApi.Renderer, protoViewFactory, ProtoViewFactory); + function Compiler(reader, cache, templateResolver, componentUrlMapper, urlResolver, render, protoViewFactory) { this._reader = reader; this._compilerCache = cache; this._compiling = MapWrapper.create(); @@ -30040,42 +25235,40 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert this._componentUrlMapper = componentUrlMapper; this._urlResolver = urlResolver; this._appUrl = urlResolver.resolve(null, './'); - this._renderer = renderer; + this._render = render; this._protoViewFactory = protoViewFactory; } return ($traceurRuntime.createClass)(Compiler, { _bindDirective: function(directiveTypeOrBinding) { if (directiveTypeOrBinding instanceof DirectiveBinding) { - return assert.returnType((directiveTypeOrBinding), DirectiveBinding); + return directiveTypeOrBinding; } else if (directiveTypeOrBinding instanceof Binding) { var meta = this._reader.read(directiveTypeOrBinding.token); - return assert.returnType((DirectiveBinding.createFromBinding(directiveTypeOrBinding, meta.annotation)), DirectiveBinding); + return DirectiveBinding.createFromBinding(directiveTypeOrBinding, meta.annotation); } else { var meta$__2 = this._reader.read(directiveTypeOrBinding); - return assert.returnType((DirectiveBinding.createFromType(meta$__2.type, meta$__2.annotation)), DirectiveBinding); + return DirectiveBinding.createFromType(meta$__2.type, meta$__2.annotation); } }, compileInHost: function(componentTypeOrBinding) { var $__0 = this; - assert.argumentTypes(componentTypeOrBinding, assert.type.any); var componentBinding = this._bindDirective(componentTypeOrBinding); this._assertTypeIsComponent(componentBinding); var directiveMetadata = Compiler.buildRenderDirective(componentBinding); - return assert.returnType((this._renderer.createHostProtoView(directiveMetadata).then((function(hostRenderPv) { - return $__0._compileNestedProtoViews(null, hostRenderPv, [componentBinding], true); + return this._render.compileHost(directiveMetadata).then((function(hostRenderPv) { + return $__0._compileNestedProtoViews(null, null, hostRenderPv, [componentBinding], true); })).then((function(appProtoView) { return new ProtoViewRef(appProtoView); - }))), assert.genericType(Promise, ProtoViewRef)); + })); }, compile: function(component) { - assert.argumentTypes(component, Type); var componentBinding = this._bindDirective(component); this._assertTypeIsComponent(componentBinding); var protoView = this._compile(componentBinding); var pvPromise = PromiseWrapper.isPromise(protoView) ? protoView : PromiseWrapper.resolve(protoView); - return assert.returnType((pvPromise.then((function(appProtoView) { + return pvPromise.then((function(appProtoView) { return new ProtoViewRef(appProtoView); - }))), assert.genericType(Promise, ProtoViewRef)); + })); }, _compile: function(componentBinding) { var $__0 = this; @@ -30092,27 +25285,20 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert if (isBlank(template)) { return null; } - if (isPresent(template.renderer)) { - var directives = []; - pvPromise = this._renderer.createImperativeComponentProtoView(template.renderer).then((function(renderPv) { - return $__0._compileNestedProtoViews(componentBinding, renderPv, directives, true); - })); - } else { - var directives = ListWrapper.map(this._flattenDirectives(template), (function(directive) { - return $__0._bindDirective(directive); - })); - var renderTemplate = this._buildRenderTemplate(component, template, directives); - pvPromise = this._renderer.compile(renderTemplate).then((function(renderPv) { - return $__0._compileNestedProtoViews(componentBinding, renderPv, directives, true); - })); - } + var directives = ListWrapper.map(this._flattenDirectives(template), (function(directive) { + return $__0._bindDirective(directive); + })); + var renderTemplate = this._buildRenderTemplate(component, template, directives); + pvPromise = this._render.compile(renderTemplate).then((function(renderPv) { + return $__0._compileNestedProtoViews(null, componentBinding, renderPv, directives, true); + })); MapWrapper.set(this._compiling, component, pvPromise); return pvPromise; }, - _compileNestedProtoViews: function(componentBinding, renderPv, directives, isComponentRootView) { + _compileNestedProtoViews: function(parentProtoView, componentBinding, renderPv, directives, isComponentRootView) { var $__0 = this; var nestedPVPromises = []; - var protoView = this._protoViewFactory.createProtoView(componentBinding, renderPv, directives); + var protoView = this._protoViewFactory.createProtoView(parentProtoView, componentBinding, renderPv, directives); if (isComponentRootView && isPresent(componentBinding)) { var component = componentBinding.key.token; this._compilerCache.set(component, protoView); @@ -30124,13 +25310,12 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert var nestedRenderProtoView = renderPv.elementBinders[binderIndex].nestedProtoView; var elementBinderDone = (function(nestedPv) { elementBinder.nestedProtoView = nestedPv; - nestedPv.parentProtoView = isPresent(nestedComponent) ? null : protoView; }); var nestedCall = null; if (isPresent(nestedComponent)) { nestedCall = $__0._compile(nestedComponent); } else if (isPresent(nestedRenderProtoView)) { - nestedCall = $__0._compileNestedProtoViews(componentBinding, nestedRenderProtoView, directives, false); + nestedCall = $__0._compileNestedProtoViews(protoView, componentBinding, nestedRenderProtoView, directives, false); } if (PromiseWrapper.isPromise(nestedCall)) { ListWrapper.push(nestedPVPromises, nestedCall.then(elementBinderDone)); @@ -30140,14 +25325,6 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert binderIndex++; })); var protoViewDone = (function(_) { - var childComponentRenderPvRefs = []; - ListWrapper.forEach(protoView.elementBinders, (function(eb) { - if (isPresent(eb.componentDirective)) { - var componentPv = eb.nestedProtoView; - ListWrapper.push(childComponentRenderPvRefs, isPresent(componentPv) ? componentPv.render : null); - } - })); - $__0._renderer.mergeChildComponentProtoViews(protoView.render, childComponentRenderPvRefs); return protoView; }); if (nestedPVPromises.length > 0) { @@ -30164,23 +25341,21 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert } else if (isPresent(view.template)) { templateAbsUrl = componentUrl; } - return assert.returnType((new renderApi.ViewDefinition({ + return new renderApi.ViewDefinition({ componentId: stringify(component), absUrl: templateAbsUrl, template: view.template, directives: ListWrapper.map(directives, Compiler.buildRenderDirective) - })), renderApi.ViewDefinition); + }); }, _flattenDirectives: function(template) { - assert.argumentTypes(template, View); if (isBlank(template.directives)) - return assert.returnType(([]), assert.genericType(List, Type)); + return []; var directives = []; this._flattenList(template.directives, directives); - return assert.returnType((directives), assert.genericType(List, Type)); + return directives; }, _flattenList: function(tree, out) { - assert.argumentTypes(tree, assert.genericType(List, assert.type.any), out, assert.genericType(List, Type)); for (var i = 0; i < tree.length; i++) { var item = tree[i]; if (ListWrapper.isList(item)) { @@ -30191,7 +25366,6 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert } }, _assertTypeIsComponent: function(directiveBinding) { - assert.argumentTypes(directiveBinding, DirectiveBinding); if (!(directiveBinding.annotation instanceof Component)) { throw new BaseException(("Could not load '" + stringify(directiveBinding.key.token) + "' because it is not a component.")); } @@ -30199,12 +25373,11 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert }, {buildRenderDirective: function(directiveBinding) { var ann = directiveBinding.annotation; var renderType; - var compileChildren = true; + var compileChildren = ann.compileChildren; if (ann instanceof Component) { renderType = renderApi.DirectiveMetadata.COMPONENT_TYPE; - } else if (ann instanceof Decorator) { - renderType = renderApi.DirectiveMetadata.DECORATOR_TYPE; - compileChildren = ann.compileChildren; + } else { + renderType = renderApi.DirectiveMetadata.DIRECTIVE_TYPE; } var readAttributes = []; ListWrapper.forEach(directiveBinding.dependencies, (function(dep) { @@ -30212,16 +25385,18 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert ListWrapper.push(readAttributes, dep.attributeName); } })); - return assert.returnType((new renderApi.DirectiveMetadata({ + return new renderApi.DirectiveMetadata({ id: stringify(directiveBinding.key.token), type: renderType, selector: ann.selector, compileChildren: compileChildren, hostListeners: isPresent(ann.hostListeners) ? MapWrapper.createFromStringMap(ann.hostListeners) : null, hostProperties: isPresent(ann.hostProperties) ? MapWrapper.createFromStringMap(ann.hostProperties) : null, + hostAttributes: isPresent(ann.hostAttributes) ? MapWrapper.createFromStringMap(ann.hostAttributes) : null, + hostActions: isPresent(ann.hostActions) ? MapWrapper.createFromStringMap(ann.hostActions) : null, properties: isPresent(ann.properties) ? MapWrapper.createFromStringMap(ann.properties) : null, readAttributes: readAttributes - })), renderApi.DirectiveMetadata); + }); }}); }()); $__export("Compiler", Compiler); @@ -30229,7 +25404,7 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert return [new Injectable()]; }}); Object.defineProperty(Compiler, "parameters", {get: function() { - return [[DirectiveMetadataReader], [CompilerCache], [TemplateResolver], [ComponentUrlMapper], [UrlResolver], [renderApi.Renderer], [ProtoViewFactory]]; + return [[DirectiveMetadataReader], [CompilerCache], [TemplateResolver], [ComponentUrlMapper], [UrlResolver], [renderApi.RenderCompiler], [ProtoViewFactory]]; }}); Object.defineProperty(Compiler.prototype.compileInHost, "parameters", {get: function() { return [[assert.type.any]]; @@ -30253,14 +25428,12 @@ System.register("angular2/src/core/compiler/compiler", ["rtts_assert/rtts_assert }; }); -System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "angular2/di", "angular2/src/facade/lang", "angular2/src/dom/browser_adapter", "angular2/src/dom/dom_adapter", "angular2/src/core/compiler/compiler", "angular2/src/reflection/reflection", "angular2/change_detection", "angular2/src/core/exception_handler", "angular2/src/render/dom/compiler/template_loader", "angular2/src/core/compiler/template_resolver", "angular2/src/core/compiler/directive_metadata_reader", "angular2/src/facade/collection", "angular2/src/facade/async", "angular2/src/core/zone/vm_turn_zone", "angular2/src/core/life_cycle/life_cycle", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy", "angular2/src/services/xhr", "angular2/src/services/xhr_impl", "angular2/src/render/dom/events/event_manager", "angular2/src/render/dom/events/key_events", "angular2/src/render/dom/events/hammer_gestures", "angular2/src/di/binding", "angular2/src/core/compiler/component_url_mapper", "angular2/src/services/url_resolver", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/style_inliner", "angular2/src/core/compiler/dynamic_component_loader", "angular2/src/core/testability/testability", "angular2/src/core/compiler/view_pool", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/view_manager_utils", "angular2/src/core/compiler/proto_view_factory", "angular2/src/render/api", "angular2/src/render/dom/direct_dom_renderer", "angular2/src/render/dom/compiler/compiler", "angular2/src/render/dom/view/view_factory", "angular2/src/render/dom/view/view_hydrator", "angular2/src/core/compiler/view_ref", "angular2/src/core/application_tokens"], function($__export) { +System.register("angular2/src/core/application", ["angular2/di", "angular2/src/facade/lang", "angular2/src/dom/browser_adapter", "angular2/src/dom/dom_adapter", "angular2/src/core/compiler/compiler", "angular2/src/reflection/reflection", "angular2/change_detection", "angular2/src/core/exception_handler", "angular2/src/render/dom/compiler/template_loader", "angular2/src/core/compiler/template_resolver", "angular2/src/core/compiler/directive_metadata_reader", "angular2/src/facade/collection", "angular2/src/facade/async", "angular2/src/core/zone/ng_zone", "angular2/src/core/life_cycle/life_cycle", "angular2/src/render/dom/shadow_dom/shadow_dom_strategy", "angular2/src/render/dom/shadow_dom/emulated_unscoped_shadow_dom_strategy", "angular2/src/services/xhr", "angular2/src/services/xhr_impl", "angular2/src/render/dom/events/event_manager", "angular2/src/render/dom/events/key_events", "angular2/src/render/dom/events/hammer_gestures", "angular2/src/di/binding", "angular2/src/core/compiler/component_url_mapper", "angular2/src/services/url_resolver", "angular2/src/render/dom/shadow_dom/style_url_resolver", "angular2/src/render/dom/shadow_dom/style_inliner", "angular2/src/core/compiler/dynamic_component_loader", "angular2/src/core/testability/testability", "angular2/src/core/compiler/view_pool", "angular2/src/core/compiler/view_manager", "angular2/src/core/compiler/view_manager_utils", "angular2/src/core/compiler/proto_view_factory", "angular2/src/render/api", "angular2/src/render/dom/dom_renderer", "angular2/src/render/dom/view/view", "angular2/src/render/dom/compiler/compiler", "angular2/src/core/compiler/view_ref", "angular2/src/core/application_tokens"], function($__export) { "use strict"; var __moduleName = "angular2/src/core/application"; - var assert, - Injector, + var Injector, bind, OpaqueToken, - Optional, NumberWrapper, Type, isBlank, @@ -30289,7 +25462,7 @@ System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "an ListWrapper, Promise, PromiseWrapper, - VmTurnZone, + NgZone, LifeCycle, ShadowDomStrategy, EmulatedUnscopedShadowDomStrategy, @@ -30314,65 +25487,59 @@ System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "an AppViewManagerUtils, ProtoViewFactory, Renderer, - DirectDomRenderer, - rc, - rvf, - rvh, + RenderCompiler, + DomRenderer, + DOCUMENT_TOKEN, + resolveInternalDomView, + DefaultDomCompiler, internalView, appComponentRefToken, - appElementToken, appComponentAnnotatedTypeToken, - appDocumentToken, _rootInjector, _rootBindings, ApplicationRef; function _injectorBindings(appComponentType) { - return assert.returnType(([bind(appDocumentToken).toValue(DOM.defaultDoc()), bind(appComponentAnnotatedTypeToken).toFactory((function(reader) { + return [bind(DOCUMENT_TOKEN).toValue(DOM.defaultDoc()), bind(appComponentAnnotatedTypeToken).toFactory((function(reader) { return reader.read(appComponentType); - }), [DirectiveMetadataReader]), bind(appElementToken).toFactory((function(appComponentAnnotatedType, appDocument) { + }), [DirectiveMetadataReader]), bind(appComponentRefToken).toAsyncFactory((function(dynamicComponentLoader, injector, appComponentAnnotatedType, testability, registry) { var selector = appComponentAnnotatedType.annotation.selector; - var element = DOM.querySelector(appDocument, selector); - if (isBlank(element)) { - throw new BaseException(("The app selector \"" + selector + "\" did not match any elements")); - } - return element; - }), [appComponentAnnotatedTypeToken, appDocumentToken]), bind(appComponentRefToken).toAsyncFactory((function(dynamicComponentLoader, injector, appElement, appComponentAnnotatedType, testability, registry) { - registry.registerApplication(appElement, testability); - return dynamicComponentLoader.loadIntoNewLocation(appComponentAnnotatedType.type, null, appElement, injector); - }), [DynamicComponentLoader, Injector, appElementToken, appComponentAnnotatedTypeToken, Testability, TestabilityRegistry]), bind(appComponentType).toFactory((function(ref) { + return dynamicComponentLoader.loadIntoNewLocation(appComponentAnnotatedType.type, null, selector, injector).then((function(componentRef) { + var domView = resolveInternalDomView(componentRef.hostView.render); + registry.registerApplication(domView.boundElements[0], testability); + return componentRef; + })); + }), [DynamicComponentLoader, Injector, appComponentAnnotatedTypeToken, Testability, TestabilityRegistry]), bind(appComponentType).toFactory((function(ref) { return ref.instance; }), [appComponentRefToken]), bind(LifeCycle).toFactory((function(exceptionHandler) { return new LifeCycle(exceptionHandler, null, assertionsEnabled()); - }), [ExceptionHandler]), bind(EventManager).toFactory((function(zone) { + }), [ExceptionHandler]), bind(EventManager).toFactory((function(ngZone) { var plugins = [new HammerGesturesPlugin(), new KeyEventsPlugin(), new DomEventsPlugin()]; - return new EventManager(plugins, zone); - }), [VmTurnZone]), bind(ShadowDomStrategy).toFactory((function(styleUrlResolver, doc) { + return new EventManager(plugins, ngZone); + }), [NgZone]), bind(ShadowDomStrategy).toFactory((function(styleUrlResolver, doc) { return new EmulatedUnscopedShadowDomStrategy(styleUrlResolver, doc.head); - }), [StyleUrlResolver, appDocumentToken]), DirectDomRenderer, bind(Renderer).toClass(DirectDomRenderer), bind(rc.Compiler).toClass(rc.DefaultCompiler), bind(rvf.ViewFactory).toFactory((function(capacity, eventManager, shadowDomStrategy) { - return new rvf.ViewFactory(capacity, eventManager, shadowDomStrategy); - }), [rvf.VIEW_POOL_CAPACITY, EventManager, ShadowDomStrategy]), bind(rvf.VIEW_POOL_CAPACITY).toValue(10000), rvh.RenderViewHydrator, ProtoViewFactory, bind(AppViewPool).toFactory((function(capacity) { + }), [StyleUrlResolver, DOCUMENT_TOKEN]), bind(DomRenderer).toFactory((function(eventManager, shadowDomStrategy, doc) { + return new DomRenderer(eventManager, shadowDomStrategy, doc); + }), [EventManager, ShadowDomStrategy, DOCUMENT_TOKEN]), DefaultDomCompiler, bind(Renderer).toAlias(DomRenderer), bind(RenderCompiler).toAlias(DefaultDomCompiler), ProtoViewFactory, bind(AppViewPool).toFactory((function(capacity) { return new AppViewPool(capacity); - }), [APP_VIEW_POOL_CAPACITY]), bind(APP_VIEW_POOL_CAPACITY).toValue(10000), AppViewManager, AppViewManagerUtils, Compiler, CompilerCache, TemplateResolver, bind(PipeRegistry).toValue(defaultPipeRegistry), bind(ChangeDetection).toClass(DynamicChangeDetection), TemplateLoader, DirectiveMetadataReader, Parser, Lexer, ExceptionHandler, bind(XHR).toValue(new XHRImpl()), ComponentUrlMapper, UrlResolver, StyleUrlResolver, StyleInliner, DynamicComponentLoader, Testability]), assert.genericType(List, Binding)); + }), [APP_VIEW_POOL_CAPACITY]), bind(APP_VIEW_POOL_CAPACITY).toValue(10000), AppViewManager, AppViewManagerUtils, Compiler, CompilerCache, TemplateResolver, bind(PipeRegistry).toValue(defaultPipeRegistry), bind(ChangeDetection).toClass(DynamicChangeDetection), TemplateLoader, DirectiveMetadataReader, Parser, Lexer, ExceptionHandler, bind(XHR).toValue(new XHRImpl()), ComponentUrlMapper, UrlResolver, StyleUrlResolver, StyleInliner, DynamicComponentLoader, Testability]; } - function _createVmZone(givenReporter) { - assert.argumentTypes(givenReporter, Function); + function _createNgZone(givenReporter) { var defaultErrorReporter = (function(exception, stackTrace) { var longStackTrace = ListWrapper.join(stackTrace, "\n\n-----async gap-----\n"); - print((exception + "\n\n" + longStackTrace)); + DOM.logError((exception + "\n\n" + longStackTrace)); throw exception; }); var reporter = isPresent(givenReporter) ? givenReporter : defaultErrorReporter; - var zone = new VmTurnZone({enableLongStackTrace: assertionsEnabled()}); + var zone = new NgZone({enableLongStackTrace: assertionsEnabled()}); zone.initCallbacks({onErrorHandler: reporter}); - return assert.returnType((zone), VmTurnZone); + return zone; } function bootstrap(appComponentType) { var componentInjectableBindings = arguments[1] !== (void 0) ? arguments[1] : null; var errorReporter = arguments[2] !== (void 0) ? arguments[2] : null; - assert.argumentTypes(appComponentType, Type, componentInjectableBindings, assert.genericType(List, Binding), errorReporter, Function); BrowserDomAdapter.makeCurrent(); var bootstrapProcess = PromiseWrapper.completer(); - var zone = _createVmZone(errorReporter); + var zone = _createNgZone(errorReporter); zone.run((function() { var appInjector = _createAppInjector(appComponentType, componentInjectableBindings, zone); PromiseWrapper.then(appInjector.asyncGet(appComponentRefToken), (function(componentRef) { @@ -30385,25 +25552,21 @@ System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "an bootstrapProcess.reject(err); })); })); - return assert.returnType((bootstrapProcess.promise), assert.genericType(Promise, ApplicationRef)); + return bootstrapProcess.promise; } function _createAppInjector(appComponentType, bindings, zone) { - assert.argumentTypes(appComponentType, Type, bindings, assert.genericType(List, Binding), zone, VmTurnZone); if (isBlank(_rootInjector)) _rootInjector = Injector.resolveAndCreate(_rootBindings); var mergedBindings = isPresent(bindings) ? ListWrapper.concat(_injectorBindings(appComponentType), bindings) : _injectorBindings(appComponentType); - ListWrapper.push(mergedBindings, bind(VmTurnZone).toValue(zone)); - return assert.returnType((_rootInjector.resolveAndCreateChild(mergedBindings)), Injector); + ListWrapper.push(mergedBindings, bind(NgZone).toValue(zone)); + return _rootInjector.resolveAndCreateChild(mergedBindings); } $__export("bootstrap", bootstrap); return { setters: [function($__m) { - assert = $__m.assert; - }, function($__m) { Injector = $__m.Injector; bind = $__m.bind; OpaqueToken = $__m.OpaqueToken; - Optional = $__m.Optional; }, function($__m) { NumberWrapper = $__m.NumberWrapper; Type = $__m.Type; @@ -30445,7 +25608,7 @@ System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "an Promise = $__m.Promise; PromiseWrapper = $__m.PromiseWrapper; }, function($__m) { - VmTurnZone = $__m.VmTurnZone; + NgZone = $__m.NgZone; }, function($__m) { LifeCycle = $__m.LifeCycle; }, function($__m) { @@ -30490,25 +25653,23 @@ System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "an ProtoViewFactory = $__m.ProtoViewFactory; }, function($__m) { Renderer = $__m.Renderer; + RenderCompiler = $__m.RenderCompiler; }, function($__m) { - DirectDomRenderer = $__m.DirectDomRenderer; + DomRenderer = $__m.DomRenderer; + DOCUMENT_TOKEN = $__m.DOCUMENT_TOKEN; }, function($__m) { - rc = $__m; + resolveInternalDomView = $__m.resolveInternalDomView; }, function($__m) { - rvf = $__m; - }, function($__m) { - rvh = $__m; + DefaultDomCompiler = $__m.DefaultDomCompiler; }, function($__m) { internalView = $__m.internalView; }, function($__m) { appComponentRefToken = $__m.appComponentRefToken; - appElementToken = $__m.appElementToken; appComponentAnnotatedTypeToken = $__m.appComponentAnnotatedTypeToken; - appDocumentToken = $__m.appDocumentToken; }], execute: function() { _rootBindings = [bind(Reflector).toValue(reflector), TestabilityRegistry]; - Object.defineProperty(_createVmZone, "parameters", {get: function() { + Object.defineProperty(_createNgZone, "parameters", {get: function() { return [[Function]]; }}); Object.defineProperty(bootstrap, "parameters", {get: function() { @@ -30516,7 +25677,6 @@ System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "an }}); ApplicationRef = (function() { function ApplicationRef(hostComponent, injector) { - assert.argumentTypes(hostComponent, ComponentRef, injector, Injector); this._hostComponent = hostComponent; this._injector = injector; } @@ -30537,7 +25697,7 @@ System.register("angular2/src/core/application", ["rtts_assert/rtts_assert", "an return [[ComponentRef], [Injector]]; }}); Object.defineProperty(_createAppInjector, "parameters", {get: function() { - return [[Type], [assert.genericType(List, Binding)], [VmTurnZone]]; + return [[Type], [assert.genericType(List, Binding)], [NgZone]]; }}); } }; @@ -30643,7 +25803,7 @@ System.register("angular2/core", ["angular2/src/core/annotations/visibility", "a }; }); -System.register("angular2/angular2", ["angular2/change_detection", "angular2/core", "angular2/annotations", "angular2/directives", "angular2/forms", "angular2/src/facade/async", "angular2/src/render/api", "angular2/src/render/dom/direct_dom_renderer"], function($__export) { +System.register("angular2/angular2", ["angular2/change_detection", "angular2/core", "angular2/annotations", "angular2/directives", "angular2/forms", "angular2/src/facade/async", "angular2/src/render/api", "angular2/src/render/dom/dom_renderer"], function($__export) { "use strict"; var __moduleName = "angular2/angular2"; var $__exportNames = {undefined: true}; @@ -30687,7 +25847,8 @@ System.register("angular2/angular2", ["angular2/change_detection", "angular2/cor $__export(p, $__m[p]); }); }, function($__m) { - $__export("DirectDomRenderer", $__m.DirectDomRenderer); + $__export("DomRenderer", $__m.DomRenderer); + $__export("DOCUMENT_TOKEN", $__m.DOCUMENT_TOKEN); }], execute: function() {} }; @@ -30695,5 +25856,3 @@ System.register("angular2/angular2", ["angular2/change_detection", "angular2/cor //# sourceMappingURLDisabled=angular2.dev.js.map System.config({"paths":{"*":"*.js","angular2/*":"angular2/*"}}); - -zone = zone.fork(Zone.longStackTraceZone); diff --git a/complete/index.html b/complete/index.html deleted file mode 100644 index 1d495d3..0000000 --- a/complete/index.html +++ /dev/null @@ -1,16 +0,0 @@ - - - - Angular 2 Quickstart - - - - - - - - - - diff --git a/gulpfile.js b/gulpfile.js new file mode 100644 index 0000000..cf732c4 --- /dev/null +++ b/gulpfile.js @@ -0,0 +1,35 @@ +var del = require('del'); +var gulp = require('gulp'); +var rename = require('gulp-rename'); +var ts = require('gulp-typescript'); +var tsProject = ts.createProject('tsconfig.json', {typescript: require('typescript')}); + +gulp.task('js', function() { + var tsResult = tsProject.src() + .pipe(ts(tsProject)); + + return tsResult.js + .pipe(rename({dirname: ''})) + .pipe(gulp.dest('dist/')); +}); + +gulp.task('html', function () { + return gulp.src('src/**/*.html') + .pipe(gulp.dest('dist')); +}); + +gulp.task('clean', function(done) { + del(['dist'], done); +}); + +gulp.task('libs', function () { + return gulp.src([ + 'bundle/angular2.dev.js', + 'node_modules/traceur/bin/traceur-runtime.js', + 'node_modules/es6-module-loader/dist/es6-module-loader.js', + 'node_modules/systemjs/dist/system.js' + ]) + .pipe(gulp.dest('dist/lib')); +}); + +gulp.task('default', ['js', 'libs', 'html']); \ No newline at end of file diff --git a/package.json b/package.json new file mode 100644 index 0000000..6909f79 --- /dev/null +++ b/package.json @@ -0,0 +1,29 @@ +{ + "name": "angular2-gulp-typescript", + "version": "1.0.0", + "description": "Starter app for angular2 development using gulp and typescript", + "main": "index.js", + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "repository": { + "type": "git", + "url": "https://github.com/mdausmann/angular2-gulp-typescript.git" + }, + "author": "Michael Dausmann", + "license": "MIT", + "bugs": { + "url": "https://github.com/mdausmann/angular2-gulp-typescript/issues" + }, + "homepage": "https://github.com/mdausmann/angular2-gulp-typescript", + "devDependencies": { + "del": "^1.1.1", + "gulp": "^3.8.11", + "gulp-rename": "^1.2.2", + "gulp-typescript": "^2.6.0", + "typescript": "^1.5.0-beta", + "es6-module-loader": "^0.16.6", + "systemjs": "^0.16.11", + "traceur": "0.0.87" + } +} diff --git a/complete/app.ts b/src/app.ts similarity index 82% rename from complete/app.ts rename to src/app.ts index fdad42c..740a201 100644 --- a/complete/app.ts +++ b/src/app.ts @@ -1,4 +1,4 @@ -/// +/// import {Component, bootstrap, View} from "angular2/angular2"; diff --git a/src/index.html b/src/index.html new file mode 100644 index 0000000..b9917e6 --- /dev/null +++ b/src/index.html @@ -0,0 +1,16 @@ + + + + Angular 2 Quickstart + + + + + + + + + + diff --git a/tsconfig.json b/tsconfig.json index b3e0712..b7d6556 100644 --- a/tsconfig.json +++ b/tsconfig.json @@ -9,12 +9,8 @@ "noLib": false, "emitDecoratorMetadata": true }, - "filesGlob": [ - "./**/*.ts", - "!./node_modules/**/*.ts" - ], "files": [ - "./app.ts", - "./typings/angular2/angular2.d.ts" + "src/**/*.ts", + "typings/angular2/angular2.d.ts" ] }