.
+ * For example, matching the above expression to
+ *
+ * http://www.ics.uci.edu/pub/ietf/uri/#Related
+ *
+ * results in the following subexpression matches:
+ *
+ * $1 = http:
+ * $2 = http
+ * $3 = //www.ics.uci.edu
+ * $4 = www.ics.uci.edu
+ * $5 = /pub/ietf/uri/
+ * $6 =
+ * $7 =
+ * $8 = #Related
+ * $9 = Related
+ *
+ * where indicates that the component is not present, as is the
+ * case for the query component in the above example. Therefore, we can
+ * determine the value of the five components as
+ *
+ * scheme = $2
+ * authority = $4
+ * path = $5
+ * query = $7
+ * fragment = $9
+ *
+ *
+ * The regular expression has been modified slightly to expose the
+ * userInfo, domain, and port separately from the authority.
+ * The modified version yields
+ *
+ * $1 = http scheme
+ * $2 = userInfo -\
+ * $3 = www.ics.uci.edu domain | authority
+ * $4 = port -/
+ * $5 = /pub/ietf/uri/ path
+ * $6 = query without ?
+ * $7 = Related fragment without #
+ *
+ * @type {!RegExp}
+ * @internal
+ */
+ var _splitRe = lang_1.RegExpWrapper.create('^' +
+ '(?:' +
+ '([^:/?#.]+)' +
+ // used by other URL parts such as :,
+ // ?, /, #, and .
+ ':)?' +
+ '(?://' +
+ '(?:([^/?#]*)@)?' +
+ '([\\w\\d\\-\\u0100-\\uffff.%]*)' +
+ // digits, dashes, dots, percent
+ // escapes, and unicode characters.
+ '(?::([0-9]+))?' +
+ ')?' +
+ '([^?#]+)?' +
+ '(?:\\?([^#]*))?' +
+ '(?:#(.*))?' +
+ '$');
+ /**
+ * The index of each URI component in the return value of goog.uri.utils.split.
+ * @enum {number}
+ */
+ var _ComponentIndex;
+ (function (_ComponentIndex) {
+ _ComponentIndex[_ComponentIndex["Scheme"] = 1] = "Scheme";
+ _ComponentIndex[_ComponentIndex["UserInfo"] = 2] = "UserInfo";
+ _ComponentIndex[_ComponentIndex["Domain"] = 3] = "Domain";
+ _ComponentIndex[_ComponentIndex["Port"] = 4] = "Port";
+ _ComponentIndex[_ComponentIndex["Path"] = 5] = "Path";
+ _ComponentIndex[_ComponentIndex["QueryData"] = 6] = "QueryData";
+ _ComponentIndex[_ComponentIndex["Fragment"] = 7] = "Fragment";
+ })(_ComponentIndex || (_ComponentIndex = {}));
+ /**
+ * Splits a URI into its component parts.
+ *
+ * Each component can be accessed via the component indices; for example:
+ *
+ * goog.uri.utils.split(someStr)[goog.uri.utils.CompontentIndex.QUERY_DATA];
+ *
+ *
+ * @param {string} uri The URI string to examine.
+ * @return {!Array.} Each component still URI-encoded.
+ * Each component that is present will contain the encoded value, whereas
+ * components that are not present will be undefined or empty, depending
+ * on the browser's regular expression implementation. Never null, since
+ * arbitrary strings may still look like path names.
+ */
+ function _split(uri) {
+ return lang_1.RegExpWrapper.firstMatch(_splitRe, uri);
+ }
+ /**
+ * Removes dot segments in given path component, as described in
+ * RFC 3986, section 5.2.4.
+ *
+ * @param {string} path A non-empty path component.
+ * @return {string} Path component with removed dot segments.
+ */
+ function _removeDotSegments(path) {
+ if (path == '/')
+ return '/';
+ var leadingSlash = path[0] == '/' ? '/' : '';
+ var trailingSlash = path[path.length - 1] === '/' ? '/' : '';
+ var segments = path.split('/');
+ var out = [];
+ var up = 0;
+ for (var pos = 0; pos < segments.length; pos++) {
+ var segment = segments[pos];
+ switch (segment) {
+ case '':
+ case '.':
+ break;
+ case '..':
+ if (out.length > 0) {
+ out.pop();
+ }
+ else {
+ up++;
+ }
+ break;
+ default:
+ out.push(segment);
+ }
+ }
+ if (leadingSlash == '') {
+ while (up-- > 0) {
+ out.unshift('..');
+ }
+ if (out.length === 0)
+ out.push('.');
+ }
+ return leadingSlash + out.join('/') + trailingSlash;
+ }
+ /**
+ * Takes an array of the parts from split and canonicalizes the path part
+ * and then joins all the parts.
+ * @param {Array.} parts
+ * @return {string}
+ */
+ function _joinAndCanonicalizePath(parts) {
+ var path = parts[_ComponentIndex.Path];
+ path = lang_1.isBlank(path) ? '' : _removeDotSegments(path);
+ parts[_ComponentIndex.Path] = path;
+ return _buildFromEncodedParts(parts[_ComponentIndex.Scheme], parts[_ComponentIndex.UserInfo], parts[_ComponentIndex.Domain], parts[_ComponentIndex.Port], path, parts[_ComponentIndex.QueryData], parts[_ComponentIndex.Fragment]);
+ }
+ /**
+ * Resolves a URL.
+ * @param {string} base The URL acting as the base URL.
+ * @param {string} to The URL to resolve.
+ * @return {string}
+ */
+ function _resolveUrl(base, url) {
+ var parts = _split(encodeURI(url));
+ var baseParts = _split(base);
+ if (lang_1.isPresent(parts[_ComponentIndex.Scheme])) {
+ return _joinAndCanonicalizePath(parts);
+ }
+ else {
+ parts[_ComponentIndex.Scheme] = baseParts[_ComponentIndex.Scheme];
+ }
+ for (var i = _ComponentIndex.Scheme; i <= _ComponentIndex.Port; i++) {
+ if (lang_1.isBlank(parts[i])) {
+ parts[i] = baseParts[i];
+ }
+ }
+ if (parts[_ComponentIndex.Path][0] == '/') {
+ return _joinAndCanonicalizePath(parts);
+ }
+ var path = baseParts[_ComponentIndex.Path];
+ if (lang_1.isBlank(path))
+ path = '/';
+ var index = path.lastIndexOf('/');
+ path = path.substring(0, index + 1) + parts[_ComponentIndex.Path];
+ parts[_ComponentIndex.Path] = path;
+ return _joinAndCanonicalizePath(parts);
+ }
+ //# sourceMappingURL=url_resolver.js.map
+
+/***/ },
+/* 31 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var core_1 = __webpack_require__(1);
+ var core_private_1 = __webpack_require__(13);
+ var lang_1 = __webpack_require__(3);
+ var compile_metadata_1 = __webpack_require__(16);
+ var o = __webpack_require__(10);
+ var identifiers_1 = __webpack_require__(17);
+ function _enumExpression(classIdentifier, value) {
+ if (lang_1.isBlank(value))
+ return o.NULL_EXPR;
+ var name = lang_1.resolveEnumToken(classIdentifier.runtime, value);
+ return o.importExpr(new compile_metadata_1.CompileIdentifierMetadata({
+ name: classIdentifier.name + "." + name,
+ moduleUrl: classIdentifier.moduleUrl,
+ runtime: value
+ }));
+ }
+ var ViewTypeEnum = (function () {
+ function ViewTypeEnum() {
+ }
+ ViewTypeEnum.fromValue = function (value) {
+ return _enumExpression(identifiers_1.Identifiers.ViewType, value);
+ };
+ ViewTypeEnum.HOST = ViewTypeEnum.fromValue(core_private_1.ViewType.HOST);
+ ViewTypeEnum.COMPONENT = ViewTypeEnum.fromValue(core_private_1.ViewType.COMPONENT);
+ ViewTypeEnum.EMBEDDED = ViewTypeEnum.fromValue(core_private_1.ViewType.EMBEDDED);
+ return ViewTypeEnum;
+ }());
+ exports.ViewTypeEnum = ViewTypeEnum;
+ var ViewEncapsulationEnum = (function () {
+ function ViewEncapsulationEnum() {
+ }
+ ViewEncapsulationEnum.fromValue = function (value) {
+ return _enumExpression(identifiers_1.Identifiers.ViewEncapsulation, value);
+ };
+ ViewEncapsulationEnum.Emulated = ViewEncapsulationEnum.fromValue(core_1.ViewEncapsulation.Emulated);
+ ViewEncapsulationEnum.Native = ViewEncapsulationEnum.fromValue(core_1.ViewEncapsulation.Native);
+ ViewEncapsulationEnum.None = ViewEncapsulationEnum.fromValue(core_1.ViewEncapsulation.None);
+ return ViewEncapsulationEnum;
+ }());
+ exports.ViewEncapsulationEnum = ViewEncapsulationEnum;
+ var ChangeDetectorStateEnum = (function () {
+ function ChangeDetectorStateEnum() {
+ }
+ ChangeDetectorStateEnum.fromValue = function (value) {
+ return _enumExpression(identifiers_1.Identifiers.ChangeDetectorState, value);
+ };
+ ChangeDetectorStateEnum.NeverChecked = ChangeDetectorStateEnum.fromValue(core_private_1.ChangeDetectorState.NeverChecked);
+ ChangeDetectorStateEnum.CheckedBefore = ChangeDetectorStateEnum.fromValue(core_private_1.ChangeDetectorState.CheckedBefore);
+ ChangeDetectorStateEnum.Errored = ChangeDetectorStateEnum.fromValue(core_private_1.ChangeDetectorState.Errored);
+ return ChangeDetectorStateEnum;
+ }());
+ exports.ChangeDetectorStateEnum = ChangeDetectorStateEnum;
+ var ChangeDetectionStrategyEnum = (function () {
+ function ChangeDetectionStrategyEnum() {
+ }
+ ChangeDetectionStrategyEnum.fromValue = function (value) {
+ return _enumExpression(identifiers_1.Identifiers.ChangeDetectionStrategy, value);
+ };
+ ChangeDetectionStrategyEnum.CheckOnce = ChangeDetectionStrategyEnum.fromValue(core_1.ChangeDetectionStrategy.CheckOnce);
+ ChangeDetectionStrategyEnum.Checked = ChangeDetectionStrategyEnum.fromValue(core_1.ChangeDetectionStrategy.Checked);
+ ChangeDetectionStrategyEnum.CheckAlways = ChangeDetectionStrategyEnum.fromValue(core_1.ChangeDetectionStrategy.CheckAlways);
+ ChangeDetectionStrategyEnum.Detached = ChangeDetectionStrategyEnum.fromValue(core_1.ChangeDetectionStrategy.Detached);
+ ChangeDetectionStrategyEnum.OnPush = ChangeDetectionStrategyEnum.fromValue(core_1.ChangeDetectionStrategy.OnPush);
+ ChangeDetectionStrategyEnum.Default = ChangeDetectionStrategyEnum.fromValue(core_1.ChangeDetectionStrategy.Default);
+ return ChangeDetectionStrategyEnum;
+ }());
+ exports.ChangeDetectionStrategyEnum = ChangeDetectionStrategyEnum;
+ var ViewConstructorVars = (function () {
+ function ViewConstructorVars() {
+ }
+ ViewConstructorVars.viewUtils = o.variable('viewUtils');
+ ViewConstructorVars.parentInjector = o.variable('parentInjector');
+ ViewConstructorVars.declarationEl = o.variable('declarationEl');
+ return ViewConstructorVars;
+ }());
+ exports.ViewConstructorVars = ViewConstructorVars;
+ var ViewProperties = (function () {
+ function ViewProperties() {
+ }
+ ViewProperties.renderer = o.THIS_EXPR.prop('renderer');
+ ViewProperties.projectableNodes = o.THIS_EXPR.prop('projectableNodes');
+ ViewProperties.viewUtils = o.THIS_EXPR.prop('viewUtils');
+ return ViewProperties;
+ }());
+ exports.ViewProperties = ViewProperties;
+ var EventHandlerVars = (function () {
+ function EventHandlerVars() {
+ }
+ EventHandlerVars.event = o.variable('$event');
+ return EventHandlerVars;
+ }());
+ exports.EventHandlerVars = EventHandlerVars;
+ var InjectMethodVars = (function () {
+ function InjectMethodVars() {
+ }
+ InjectMethodVars.token = o.variable('token');
+ InjectMethodVars.requestNodeIndex = o.variable('requestNodeIndex');
+ InjectMethodVars.notFoundResult = o.variable('notFoundResult');
+ return InjectMethodVars;
+ }());
+ exports.InjectMethodVars = InjectMethodVars;
+ var DetectChangesVars = (function () {
+ function DetectChangesVars() {
+ }
+ DetectChangesVars.throwOnChange = o.variable("throwOnChange");
+ DetectChangesVars.changes = o.variable("changes");
+ DetectChangesVars.changed = o.variable("changed");
+ DetectChangesVars.valUnwrapper = o.variable("valUnwrapper");
+ return DetectChangesVars;
+ }());
+ exports.DetectChangesVars = DetectChangesVars;
+ //# sourceMappingURL=constants.js.map
+
+/***/ },
+/* 32 */,
+/* 33 */,
+/* 34 */,
+/* 35 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var core_1 = __webpack_require__(1);
+ var exceptions_1 = __webpack_require__(121);
+ var collection_1 = __webpack_require__(22);
+ exports.EVENT_MANAGER_PLUGINS =
+ /*@ts2dart_const*/ new core_1.OpaqueToken("EventManagerPlugins");
+ var EventManager = (function () {
+ function EventManager(plugins, _zone) {
+ var _this = this;
+ this._zone = _zone;
+ plugins.forEach(function (p) { return p.manager = _this; });
+ this._plugins = collection_1.ListWrapper.reversed(plugins);
+ }
+ EventManager.prototype.addEventListener = function (element, eventName, handler) {
+ var plugin = this._findPluginFor(eventName);
+ return plugin.addEventListener(element, eventName, handler);
+ };
+ EventManager.prototype.addGlobalEventListener = function (target, eventName, handler) {
+ var plugin = this._findPluginFor(eventName);
+ return plugin.addGlobalEventListener(target, eventName, handler);
+ };
+ EventManager.prototype.getZone = function () { return this._zone; };
+ /** @internal */
+ EventManager.prototype._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 exceptions_1.BaseException("No event manager plugin found for event " + eventName);
+ };
+ EventManager.decorators = [
+ { type: core_1.Injectable },
+ ];
+ EventManager.ctorParameters = [
+ { type: undefined, decorators: [{ type: core_1.Inject, args: [exports.EVENT_MANAGER_PLUGINS,] },] },
+ { type: core_1.NgZone, },
+ ];
+ return EventManager;
+ }());
+ exports.EventManager = EventManager;
+ var EventManagerPlugin = (function () {
+ function EventManagerPlugin() {
+ }
+ // That is equivalent to having supporting $event.target
+ EventManagerPlugin.prototype.supports = function (eventName) { return false; };
+ EventManagerPlugin.prototype.addEventListener = function (element, eventName, handler) {
+ throw "not implemented";
+ };
+ EventManagerPlugin.prototype.addGlobalEventListener = function (element, eventName, handler) {
+ throw "not implemented";
+ };
+ return EventManagerPlugin;
+ }());
+ exports.EventManagerPlugin = EventManagerPlugin;
+ //# sourceMappingURL=event_manager.js.map
+
+/***/ },
+/* 36 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var lang_1 = __webpack_require__(4);
+ (function (Ng2BootstrapTheme) {
+ Ng2BootstrapTheme[Ng2BootstrapTheme["BS3"] = 1] = "BS3";
+ Ng2BootstrapTheme[Ng2BootstrapTheme["BS4"] = 2] = "BS4";
+ })(exports.Ng2BootstrapTheme || (exports.Ng2BootstrapTheme = {}));
+ var Ng2BootstrapTheme = exports.Ng2BootstrapTheme;
+ var Ng2BootstrapConfig = (function () {
+ function Ng2BootstrapConfig() {
+ }
+ Object.defineProperty(Ng2BootstrapConfig, "theme", {
+ get: function () {
+ // hack as for now
+ if (lang_1.global && lang_1.global.__theme === 'bs4') {
+ return Ng2BootstrapTheme.BS4;
+ }
+ return (this._theme || Ng2BootstrapTheme.BS3);
+ },
+ set: function (v) {
+ this._theme = v;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ return Ng2BootstrapConfig;
+ }());
+ exports.Ng2BootstrapConfig = Ng2BootstrapConfig;
+
+
+/***/ },
+/* 37 */,
+/* 38 */,
+/* 39 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var lang_1 = __webpack_require__(3);
+ var exceptions_1 = __webpack_require__(8);
+ var o = __webpack_require__(10);
+ var identifiers_1 = __webpack_require__(17);
+ function getPropertyInView(property, callingView, definedView) {
+ if (callingView === definedView) {
+ return property;
+ }
+ else {
+ var viewProp = o.THIS_EXPR;
+ var currView = callingView;
+ while (currView !== definedView && lang_1.isPresent(currView.declarationElement.view)) {
+ currView = currView.declarationElement.view;
+ viewProp = viewProp.prop('parent');
+ }
+ if (currView !== definedView) {
+ throw new exceptions_1.BaseException("Internal error: Could not calculate a property in a parent view: " + property);
+ }
+ if (property instanceof o.ReadPropExpr) {
+ var readPropExpr_1 = property;
+ // Note: Don't cast for members of the AppView base class...
+ if (definedView.fields.some(function (field) { return field.name == readPropExpr_1.name; }) ||
+ definedView.getters.some(function (field) { return field.name == readPropExpr_1.name; })) {
+ viewProp = viewProp.cast(definedView.classType);
+ }
+ }
+ return o.replaceVarInExpression(o.THIS_EXPR.name, viewProp, property);
+ }
+ }
+ exports.getPropertyInView = getPropertyInView;
+ function injectFromViewParentInjector(token, optional) {
+ var args = [createDiTokenExpression(token)];
+ if (optional) {
+ args.push(o.NULL_EXPR);
+ }
+ return o.THIS_EXPR.prop('parentInjector').callMethod('get', args);
+ }
+ exports.injectFromViewParentInjector = injectFromViewParentInjector;
+ function getViewFactoryName(component, embeddedTemplateIndex) {
+ return "viewFactory_" + component.type.name + embeddedTemplateIndex;
+ }
+ exports.getViewFactoryName = getViewFactoryName;
+ function createDiTokenExpression(token) {
+ if (lang_1.isPresent(token.value)) {
+ return o.literal(token.value);
+ }
+ else if (token.identifierIsInstance) {
+ return o.importExpr(token.identifier)
+ .instantiate([], o.importType(token.identifier, [], [o.TypeModifier.Const]));
+ }
+ else {
+ return o.importExpr(token.identifier);
+ }
+ }
+ exports.createDiTokenExpression = createDiTokenExpression;
+ function createFlatArray(expressions) {
+ var lastNonArrayExpressions = [];
+ var result = o.literalArr([]);
+ for (var i = 0; i < expressions.length; i++) {
+ var expr = expressions[i];
+ if (expr.type instanceof o.ArrayType) {
+ if (lastNonArrayExpressions.length > 0) {
+ result =
+ result.callMethod(o.BuiltinMethod.ConcatArray, [o.literalArr(lastNonArrayExpressions)]);
+ lastNonArrayExpressions = [];
+ }
+ result = result.callMethod(o.BuiltinMethod.ConcatArray, [expr]);
+ }
+ else {
+ lastNonArrayExpressions.push(expr);
+ }
+ }
+ if (lastNonArrayExpressions.length > 0) {
+ result =
+ result.callMethod(o.BuiltinMethod.ConcatArray, [o.literalArr(lastNonArrayExpressions)]);
+ }
+ return result;
+ }
+ exports.createFlatArray = createFlatArray;
+ function createPureProxy(fn, argCount, pureProxyProp, view) {
+ view.fields.push(new o.ClassField(pureProxyProp.name, null));
+ var pureProxyId = argCount < identifiers_1.Identifiers.pureProxies.length ? identifiers_1.Identifiers.pureProxies[argCount] : null;
+ if (lang_1.isBlank(pureProxyId)) {
+ throw new exceptions_1.BaseException("Unsupported number of argument for pure functions: " + argCount);
+ }
+ view.createMethod.addStmt(o.THIS_EXPR.prop(pureProxyProp.name).set(o.importExpr(pureProxyId).callFn([fn])).toStmt());
+ }
+ exports.createPureProxy = createPureProxy;
+ //# sourceMappingURL=util.js.map
+
+/***/ },
+/* 40 */,
+/* 41 */
+4,
+/* 42 */,
+/* 43 */,
+/* 44 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+ };
+ var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+ };
+ var core_1 = __webpack_require__(1);
+ var file_uploader_class_1 = __webpack_require__(28);
+ var FileDropDirective = (function () {
+ function FileDropDirective(element) {
+ this.fileOver = new core_1.EventEmitter();
+ this.onFileDrop = new core_1.EventEmitter();
+ this.element = element;
+ }
+ FileDropDirective.prototype.getOptions = function () {
+ return this.uploader.options;
+ };
+ FileDropDirective.prototype.getFilters = function () {
+ return {};
+ };
+ FileDropDirective.prototype.onDrop = function (event) {
+ var transfer = this._getTransfer(event);
+ if (!transfer) {
+ return;
+ }
+ var options = this.getOptions();
+ var filters = this.getFilters();
+ this._preventAndStop(event);
+ this.uploader.addToQueue(transfer.files, options, filters);
+ this.fileOver.emit(false);
+ this.onFileDrop.emit(transfer.files);
+ };
+ FileDropDirective.prototype.onDragOver = function (event) {
+ var transfer = this._getTransfer(event);
+ if (!this._haveFiles(transfer.types)) {
+ return;
+ }
+ transfer.dropEffect = 'copy';
+ this._preventAndStop(event);
+ this.fileOver.emit(true);
+ };
+ FileDropDirective.prototype.onDragLeave = function (event) {
+ if (event.currentTarget === this.element[0]) {
+ return;
+ }
+ this._preventAndStop(event);
+ this.fileOver.emit(false);
+ };
+ FileDropDirective.prototype._getTransfer = function (event) {
+ return event.dataTransfer ? event.dataTransfer : event.originalEvent.dataTransfer;
+ };
+ FileDropDirective.prototype._preventAndStop = function (event) {
+ event.preventDefault();
+ event.stopPropagation();
+ };
+ FileDropDirective.prototype._haveFiles = function (types) {
+ if (!types) {
+ return false;
+ }
+ if (types.indexOf) {
+ return types.indexOf('Files') !== -1;
+ }
+ else if (types.contains) {
+ return types.contains('Files');
+ }
+ else {
+ return false;
+ }
+ };
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', file_uploader_class_1.FileUploader)
+ ], FileDropDirective.prototype, "uploader", void 0);
+ __decorate([
+ core_1.Output(),
+ __metadata('design:type', core_1.EventEmitter)
+ ], FileDropDirective.prototype, "fileOver", void 0);
+ __decorate([
+ core_1.Output(),
+ __metadata('design:type', core_1.EventEmitter)
+ ], FileDropDirective.prototype, "onFileDrop", void 0);
+ __decorate([
+ core_1.HostListener('drop', ['$event']),
+ __metadata('design:type', Function),
+ __metadata('design:paramtypes', [Object]),
+ __metadata('design:returntype', void 0)
+ ], FileDropDirective.prototype, "onDrop", null);
+ __decorate([
+ core_1.HostListener('dragover', ['$event']),
+ __metadata('design:type', Function),
+ __metadata('design:paramtypes', [Object]),
+ __metadata('design:returntype', void 0)
+ ], FileDropDirective.prototype, "onDragOver", null);
+ __decorate([
+ core_1.HostListener('dragleave', ['$event']),
+ __metadata('design:type', Function),
+ __metadata('design:paramtypes', [Object]),
+ __metadata('design:returntype', Object)
+ ], FileDropDirective.prototype, "onDragLeave", null);
+ FileDropDirective = __decorate([
+ core_1.Directive({ selector: '[ng2FileDrop]' }),
+ __metadata('design:paramtypes', [core_1.ElementRef])
+ ], FileDropDirective);
+ return FileDropDirective;
+ }());
+ exports.FileDropDirective = FileDropDirective;
+
+
+/***/ },
+/* 45 */
+/***/ function(module, exports) {
+
+ "use strict";
+ function isElement(node) {
+ return !!(node && (node.nodeName || node.prop && node.attr && node.find));
+ }
+ var FileLikeObject = (function () {
+ function FileLikeObject(fileOrInput) {
+ var isInput = isElement(fileOrInput);
+ var fakePathOrObject = isInput ? fileOrInput.value : fileOrInput;
+ var postfix = typeof fakePathOrObject === 'string' ? 'FakePath' : 'Object';
+ var method = '_createFrom' + postfix;
+ this[method](fakePathOrObject);
+ }
+ FileLikeObject.prototype._createFromFakePath = function (path) {
+ this.lastModifiedDate = void 0;
+ this.size = void 0;
+ this.type = 'like/' + path.slice(path.lastIndexOf('.') + 1).toLowerCase();
+ this.name = path.slice(path.lastIndexOf('/') + path.lastIndexOf('\\') + 2);
+ };
+ FileLikeObject.prototype._createFromObject = function (object) {
+ this.size = object.size;
+ this.type = object.type;
+ this.name = object.name;
+ };
+ return FileLikeObject;
+ }());
+ exports.FileLikeObject = FileLikeObject;
+
+
+/***/ },
+/* 46 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+ };
+ var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+ };
+ var core_1 = __webpack_require__(1);
+ var file_uploader_class_1 = __webpack_require__(28);
+ var FileSelectDirective = (function () {
+ function FileSelectDirective(element) {
+ this.element = element;
+ }
+ FileSelectDirective.prototype.getOptions = function () {
+ return this.uploader.options;
+ };
+ FileSelectDirective.prototype.getFilters = function () {
+ return void 0;
+ };
+ FileSelectDirective.prototype.isEmptyAfterSelection = function () {
+ return !!this.element.nativeElement.attributes.multiple;
+ };
+ FileSelectDirective.prototype.onChange = function () {
+ var files = this.element.nativeElement.files;
+ var options = this.getOptions();
+ var filters = this.getFilters();
+ this.uploader.addToQueue(files, options, filters);
+ if (this.isEmptyAfterSelection()) {
+ }
+ };
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', file_uploader_class_1.FileUploader)
+ ], FileSelectDirective.prototype, "uploader", void 0);
+ __decorate([
+ core_1.HostListener('change'),
+ __metadata('design:type', Function),
+ __metadata('design:paramtypes', []),
+ __metadata('design:returntype', Object)
+ ], FileSelectDirective.prototype, "onChange", null);
+ FileSelectDirective = __decorate([
+ core_1.Directive({ selector: '[ng2FileSelect]' }),
+ __metadata('design:paramtypes', [core_1.ElementRef])
+ ], FileSelectDirective);
+ return FileSelectDirective;
+ }());
+ exports.FileSelectDirective = FileSelectDirective;
+
+
+/***/ },
+/* 47 */,
+/* 48 */,
+/* 49 */,
+/* 50 */,
+/* 51 */,
+/* 52 */,
+/* 53 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var lang_1 = __webpack_require__(3);
+ var exceptions_1 = __webpack_require__(8);
+ var identifiers_1 = __webpack_require__(17);
+ var CompilerConfig = (function () {
+ function CompilerConfig(genDebugInfo, logBindingUpdate, useJit, renderTypes) {
+ if (renderTypes === void 0) { renderTypes = null; }
+ this.genDebugInfo = genDebugInfo;
+ this.logBindingUpdate = logBindingUpdate;
+ this.useJit = useJit;
+ if (lang_1.isBlank(renderTypes)) {
+ renderTypes = new DefaultRenderTypes();
+ }
+ this.renderTypes = renderTypes;
+ }
+ return CompilerConfig;
+ }());
+ exports.CompilerConfig = CompilerConfig;
+ /**
+ * Types used for the renderer.
+ * Can be replaced to specialize the generated output to a specific renderer
+ * to help tree shaking.
+ */
+ var RenderTypes = (function () {
+ function RenderTypes() {
+ }
+ Object.defineProperty(RenderTypes.prototype, "renderer", {
+ get: function () { return exceptions_1.unimplemented(); },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(RenderTypes.prototype, "renderText", {
+ get: function () { return exceptions_1.unimplemented(); },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(RenderTypes.prototype, "renderElement", {
+ get: function () { return exceptions_1.unimplemented(); },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(RenderTypes.prototype, "renderComment", {
+ get: function () { return exceptions_1.unimplemented(); },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(RenderTypes.prototype, "renderNode", {
+ get: function () { return exceptions_1.unimplemented(); },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(RenderTypes.prototype, "renderEvent", {
+ get: function () { return exceptions_1.unimplemented(); },
+ enumerable: true,
+ configurable: true
+ });
+ return RenderTypes;
+ }());
+ exports.RenderTypes = RenderTypes;
+ var DefaultRenderTypes = (function () {
+ function DefaultRenderTypes() {
+ this.renderer = identifiers_1.Identifiers.Renderer;
+ this.renderText = null;
+ this.renderElement = null;
+ this.renderComment = null;
+ this.renderNode = null;
+ this.renderEvent = null;
+ }
+ return DefaultRenderTypes;
+ }());
+ exports.DefaultRenderTypes = DefaultRenderTypes;
+ //# sourceMappingURL=config.js.map
+
+/***/ },
+/* 54 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var lang_1 = __webpack_require__(3);
+ // see http://www.w3.org/TR/html51/syntax.html#named-character-references
+ // see https://html.spec.whatwg.org/multipage/entities.json
+ // This list is not exhaustive to keep the compiler footprint low.
+ // The `{` / `ƫ` syntax should be used when the named character reference does not exist.
+ exports.NAMED_ENTITIES = {
+ 'Aacute': '\u00C1',
+ 'aacute': '\u00E1',
+ 'Acirc': '\u00C2',
+ 'acirc': '\u00E2',
+ 'acute': '\u00B4',
+ 'AElig': '\u00C6',
+ 'aelig': '\u00E6',
+ 'Agrave': '\u00C0',
+ 'agrave': '\u00E0',
+ 'alefsym': '\u2135',
+ 'Alpha': '\u0391',
+ 'alpha': '\u03B1',
+ 'amp': '&',
+ 'and': '\u2227',
+ 'ang': '\u2220',
+ 'apos': '\u0027',
+ 'Aring': '\u00C5',
+ 'aring': '\u00E5',
+ 'asymp': '\u2248',
+ 'Atilde': '\u00C3',
+ 'atilde': '\u00E3',
+ 'Auml': '\u00C4',
+ 'auml': '\u00E4',
+ 'bdquo': '\u201E',
+ 'Beta': '\u0392',
+ 'beta': '\u03B2',
+ 'brvbar': '\u00A6',
+ 'bull': '\u2022',
+ 'cap': '\u2229',
+ 'Ccedil': '\u00C7',
+ 'ccedil': '\u00E7',
+ 'cedil': '\u00B8',
+ 'cent': '\u00A2',
+ 'Chi': '\u03A7',
+ 'chi': '\u03C7',
+ 'circ': '\u02C6',
+ 'clubs': '\u2663',
+ 'cong': '\u2245',
+ 'copy': '\u00A9',
+ 'crarr': '\u21B5',
+ 'cup': '\u222A',
+ 'curren': '\u00A4',
+ 'dagger': '\u2020',
+ 'Dagger': '\u2021',
+ 'darr': '\u2193',
+ 'dArr': '\u21D3',
+ 'deg': '\u00B0',
+ 'Delta': '\u0394',
+ 'delta': '\u03B4',
+ 'diams': '\u2666',
+ 'divide': '\u00F7',
+ 'Eacute': '\u00C9',
+ 'eacute': '\u00E9',
+ 'Ecirc': '\u00CA',
+ 'ecirc': '\u00EA',
+ 'Egrave': '\u00C8',
+ 'egrave': '\u00E8',
+ 'empty': '\u2205',
+ 'emsp': '\u2003',
+ 'ensp': '\u2002',
+ 'Epsilon': '\u0395',
+ 'epsilon': '\u03B5',
+ 'equiv': '\u2261',
+ 'Eta': '\u0397',
+ 'eta': '\u03B7',
+ 'ETH': '\u00D0',
+ 'eth': '\u00F0',
+ 'Euml': '\u00CB',
+ 'euml': '\u00EB',
+ 'euro': '\u20AC',
+ 'exist': '\u2203',
+ 'fnof': '\u0192',
+ 'forall': '\u2200',
+ 'frac12': '\u00BD',
+ 'frac14': '\u00BC',
+ 'frac34': '\u00BE',
+ 'frasl': '\u2044',
+ 'Gamma': '\u0393',
+ 'gamma': '\u03B3',
+ 'ge': '\u2265',
+ 'gt': '>',
+ 'harr': '\u2194',
+ 'hArr': '\u21D4',
+ 'hearts': '\u2665',
+ 'hellip': '\u2026',
+ 'Iacute': '\u00CD',
+ 'iacute': '\u00ED',
+ 'Icirc': '\u00CE',
+ 'icirc': '\u00EE',
+ 'iexcl': '\u00A1',
+ 'Igrave': '\u00CC',
+ 'igrave': '\u00EC',
+ 'image': '\u2111',
+ 'infin': '\u221E',
+ 'int': '\u222B',
+ 'Iota': '\u0399',
+ 'iota': '\u03B9',
+ 'iquest': '\u00BF',
+ 'isin': '\u2208',
+ 'Iuml': '\u00CF',
+ 'iuml': '\u00EF',
+ 'Kappa': '\u039A',
+ 'kappa': '\u03BA',
+ 'Lambda': '\u039B',
+ 'lambda': '\u03BB',
+ 'lang': '\u27E8',
+ 'laquo': '\u00AB',
+ 'larr': '\u2190',
+ 'lArr': '\u21D0',
+ 'lceil': '\u2308',
+ 'ldquo': '\u201C',
+ 'le': '\u2264',
+ 'lfloor': '\u230A',
+ 'lowast': '\u2217',
+ 'loz': '\u25CA',
+ 'lrm': '\u200E',
+ 'lsaquo': '\u2039',
+ 'lsquo': '\u2018',
+ 'lt': '<',
+ 'macr': '\u00AF',
+ 'mdash': '\u2014',
+ 'micro': '\u00B5',
+ 'middot': '\u00B7',
+ 'minus': '\u2212',
+ 'Mu': '\u039C',
+ 'mu': '\u03BC',
+ 'nabla': '\u2207',
+ 'nbsp': '\u00A0',
+ 'ndash': '\u2013',
+ 'ne': '\u2260',
+ 'ni': '\u220B',
+ 'not': '\u00AC',
+ 'notin': '\u2209',
+ 'nsub': '\u2284',
+ 'Ntilde': '\u00D1',
+ 'ntilde': '\u00F1',
+ 'Nu': '\u039D',
+ 'nu': '\u03BD',
+ 'Oacute': '\u00D3',
+ 'oacute': '\u00F3',
+ 'Ocirc': '\u00D4',
+ 'ocirc': '\u00F4',
+ 'OElig': '\u0152',
+ 'oelig': '\u0153',
+ 'Ograve': '\u00D2',
+ 'ograve': '\u00F2',
+ 'oline': '\u203E',
+ 'Omega': '\u03A9',
+ 'omega': '\u03C9',
+ 'Omicron': '\u039F',
+ 'omicron': '\u03BF',
+ 'oplus': '\u2295',
+ 'or': '\u2228',
+ 'ordf': '\u00AA',
+ 'ordm': '\u00BA',
+ 'Oslash': '\u00D8',
+ 'oslash': '\u00F8',
+ 'Otilde': '\u00D5',
+ 'otilde': '\u00F5',
+ 'otimes': '\u2297',
+ 'Ouml': '\u00D6',
+ 'ouml': '\u00F6',
+ 'para': '\u00B6',
+ 'permil': '\u2030',
+ 'perp': '\u22A5',
+ 'Phi': '\u03A6',
+ 'phi': '\u03C6',
+ 'Pi': '\u03A0',
+ 'pi': '\u03C0',
+ 'piv': '\u03D6',
+ 'plusmn': '\u00B1',
+ 'pound': '\u00A3',
+ 'prime': '\u2032',
+ 'Prime': '\u2033',
+ 'prod': '\u220F',
+ 'prop': '\u221D',
+ 'Psi': '\u03A8',
+ 'psi': '\u03C8',
+ 'quot': '\u0022',
+ 'radic': '\u221A',
+ 'rang': '\u27E9',
+ 'raquo': '\u00BB',
+ 'rarr': '\u2192',
+ 'rArr': '\u21D2',
+ 'rceil': '\u2309',
+ 'rdquo': '\u201D',
+ 'real': '\u211C',
+ 'reg': '\u00AE',
+ 'rfloor': '\u230B',
+ 'Rho': '\u03A1',
+ 'rho': '\u03C1',
+ 'rlm': '\u200F',
+ 'rsaquo': '\u203A',
+ 'rsquo': '\u2019',
+ 'sbquo': '\u201A',
+ 'Scaron': '\u0160',
+ 'scaron': '\u0161',
+ 'sdot': '\u22C5',
+ 'sect': '\u00A7',
+ 'shy': '\u00AD',
+ 'Sigma': '\u03A3',
+ 'sigma': '\u03C3',
+ 'sigmaf': '\u03C2',
+ 'sim': '\u223C',
+ 'spades': '\u2660',
+ 'sub': '\u2282',
+ 'sube': '\u2286',
+ 'sum': '\u2211',
+ 'sup': '\u2283',
+ 'sup1': '\u00B9',
+ 'sup2': '\u00B2',
+ 'sup3': '\u00B3',
+ 'supe': '\u2287',
+ 'szlig': '\u00DF',
+ 'Tau': '\u03A4',
+ 'tau': '\u03C4',
+ 'there4': '\u2234',
+ 'Theta': '\u0398',
+ 'theta': '\u03B8',
+ 'thetasym': '\u03D1',
+ 'thinsp': '\u2009',
+ 'THORN': '\u00DE',
+ 'thorn': '\u00FE',
+ 'tilde': '\u02DC',
+ 'times': '\u00D7',
+ 'trade': '\u2122',
+ 'Uacute': '\u00DA',
+ 'uacute': '\u00FA',
+ 'uarr': '\u2191',
+ 'uArr': '\u21D1',
+ 'Ucirc': '\u00DB',
+ 'ucirc': '\u00FB',
+ 'Ugrave': '\u00D9',
+ 'ugrave': '\u00F9',
+ 'uml': '\u00A8',
+ 'upsih': '\u03D2',
+ 'Upsilon': '\u03A5',
+ 'upsilon': '\u03C5',
+ 'Uuml': '\u00DC',
+ 'uuml': '\u00FC',
+ 'weierp': '\u2118',
+ 'Xi': '\u039E',
+ 'xi': '\u03BE',
+ 'Yacute': '\u00DD',
+ 'yacute': '\u00FD',
+ 'yen': '\u00A5',
+ 'yuml': '\u00FF',
+ 'Yuml': '\u0178',
+ 'Zeta': '\u0396',
+ 'zeta': '\u03B6',
+ 'zwj': '\u200D',
+ 'zwnj': '\u200C',
+ };
+ (function (HtmlTagContentType) {
+ HtmlTagContentType[HtmlTagContentType["RAW_TEXT"] = 0] = "RAW_TEXT";
+ HtmlTagContentType[HtmlTagContentType["ESCAPABLE_RAW_TEXT"] = 1] = "ESCAPABLE_RAW_TEXT";
+ HtmlTagContentType[HtmlTagContentType["PARSABLE_DATA"] = 2] = "PARSABLE_DATA";
+ })(exports.HtmlTagContentType || (exports.HtmlTagContentType = {}));
+ var HtmlTagContentType = exports.HtmlTagContentType;
+ var HtmlTagDefinition = (function () {
+ function HtmlTagDefinition(_a) {
+ var _this = this;
+ var _b = _a === void 0 ? {} : _a, closedByChildren = _b.closedByChildren, requiredParents = _b.requiredParents, implicitNamespacePrefix = _b.implicitNamespacePrefix, contentType = _b.contentType, closedByParent = _b.closedByParent, isVoid = _b.isVoid, ignoreFirstLf = _b.ignoreFirstLf;
+ this.closedByChildren = {};
+ this.closedByParent = false;
+ if (lang_1.isPresent(closedByChildren) && closedByChildren.length > 0) {
+ closedByChildren.forEach(function (tagName) { return _this.closedByChildren[tagName] = true; });
+ }
+ this.isVoid = lang_1.normalizeBool(isVoid);
+ this.closedByParent = lang_1.normalizeBool(closedByParent) || this.isVoid;
+ if (lang_1.isPresent(requiredParents) && requiredParents.length > 0) {
+ this.requiredParents = {};
+ this.parentToAdd = requiredParents[0];
+ requiredParents.forEach(function (tagName) { return _this.requiredParents[tagName] = true; });
+ }
+ this.implicitNamespacePrefix = implicitNamespacePrefix;
+ this.contentType = lang_1.isPresent(contentType) ? contentType : HtmlTagContentType.PARSABLE_DATA;
+ this.ignoreFirstLf = lang_1.normalizeBool(ignoreFirstLf);
+ }
+ HtmlTagDefinition.prototype.requireExtraParent = function (currentParent) {
+ if (lang_1.isBlank(this.requiredParents)) {
+ return false;
+ }
+ if (lang_1.isBlank(currentParent)) {
+ return true;
+ }
+ var lcParent = currentParent.toLowerCase();
+ return this.requiredParents[lcParent] != true && lcParent != 'template';
+ };
+ HtmlTagDefinition.prototype.isClosedByChild = function (name) {
+ return this.isVoid || lang_1.normalizeBool(this.closedByChildren[name.toLowerCase()]);
+ };
+ return HtmlTagDefinition;
+ }());
+ exports.HtmlTagDefinition = HtmlTagDefinition;
+ // see http://www.w3.org/TR/html51/syntax.html#optional-tags
+ // This implementation does not fully conform to the HTML5 spec.
+ var TAG_DEFINITIONS = {
+ 'base': new HtmlTagDefinition({ isVoid: true }),
+ 'meta': new HtmlTagDefinition({ isVoid: true }),
+ 'area': new HtmlTagDefinition({ isVoid: true }),
+ 'embed': new HtmlTagDefinition({ isVoid: true }),
+ 'link': new HtmlTagDefinition({ isVoid: true }),
+ 'img': new HtmlTagDefinition({ isVoid: true }),
+ 'input': new HtmlTagDefinition({ isVoid: true }),
+ 'param': new HtmlTagDefinition({ isVoid: true }),
+ 'hr': new HtmlTagDefinition({ isVoid: true }),
+ 'br': new HtmlTagDefinition({ isVoid: true }),
+ 'source': new HtmlTagDefinition({ isVoid: true }),
+ 'track': new HtmlTagDefinition({ isVoid: true }),
+ 'wbr': new HtmlTagDefinition({ isVoid: true }),
+ 'p': new HtmlTagDefinition({
+ closedByChildren: [
+ 'address',
+ 'article',
+ 'aside',
+ 'blockquote',
+ 'div',
+ 'dl',
+ 'fieldset',
+ 'footer',
+ 'form',
+ 'h1',
+ 'h2',
+ 'h3',
+ 'h4',
+ 'h5',
+ 'h6',
+ 'header',
+ 'hgroup',
+ 'hr',
+ 'main',
+ 'nav',
+ 'ol',
+ 'p',
+ 'pre',
+ 'section',
+ 'table',
+ 'ul'
+ ],
+ closedByParent: true
+ }),
+ 'thead': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'] }),
+ 'tbody': new HtmlTagDefinition({ closedByChildren: ['tbody', 'tfoot'], closedByParent: true }),
+ 'tfoot': new HtmlTagDefinition({ closedByChildren: ['tbody'], closedByParent: true }),
+ 'tr': new HtmlTagDefinition({
+ closedByChildren: ['tr'],
+ requiredParents: ['tbody', 'tfoot', 'thead'],
+ closedByParent: true
+ }),
+ 'td': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),
+ 'th': new HtmlTagDefinition({ closedByChildren: ['td', 'th'], closedByParent: true }),
+ 'col': new HtmlTagDefinition({ requiredParents: ['colgroup'], isVoid: true }),
+ 'svg': new HtmlTagDefinition({ implicitNamespacePrefix: 'svg' }),
+ 'math': new HtmlTagDefinition({ implicitNamespacePrefix: 'math' }),
+ 'li': new HtmlTagDefinition({ closedByChildren: ['li'], closedByParent: true }),
+ 'dt': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'] }),
+ 'dd': new HtmlTagDefinition({ closedByChildren: ['dt', 'dd'], closedByParent: true }),
+ 'rb': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),
+ 'rt': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),
+ 'rtc': new HtmlTagDefinition({ closedByChildren: ['rb', 'rtc', 'rp'], closedByParent: true }),
+ 'rp': new HtmlTagDefinition({ closedByChildren: ['rb', 'rt', 'rtc', 'rp'], closedByParent: true }),
+ 'optgroup': new HtmlTagDefinition({ closedByChildren: ['optgroup'], closedByParent: true }),
+ 'option': new HtmlTagDefinition({ closedByChildren: ['option', 'optgroup'], closedByParent: true }),
+ 'pre': new HtmlTagDefinition({ ignoreFirstLf: true }),
+ 'listing': new HtmlTagDefinition({ ignoreFirstLf: true }),
+ 'style': new HtmlTagDefinition({ contentType: HtmlTagContentType.RAW_TEXT }),
+ 'script': new HtmlTagDefinition({ contentType: HtmlTagContentType.RAW_TEXT }),
+ 'title': new HtmlTagDefinition({ contentType: HtmlTagContentType.ESCAPABLE_RAW_TEXT }),
+ 'textarea': new HtmlTagDefinition({ contentType: HtmlTagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
+ };
+ var DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();
+ function getHtmlTagDefinition(tagName) {
+ var result = TAG_DEFINITIONS[tagName.toLowerCase()];
+ return lang_1.isPresent(result) ? result : DEFAULT_TAG_DEFINITION;
+ }
+ exports.getHtmlTagDefinition = getHtmlTagDefinition;
+ var NS_PREFIX_RE = /^@([^:]+):(.+)/g;
+ function splitNsName(elementName) {
+ if (elementName[0] != '@') {
+ return [null, elementName];
+ }
+ var match = lang_1.RegExpWrapper.firstMatch(NS_PREFIX_RE, elementName);
+ return [match[1], match[2]];
+ }
+ exports.splitNsName = splitNsName;
+ function getNsPrefix(elementName) {
+ return splitNsName(elementName)[0];
+ }
+ exports.getNsPrefix = getNsPrefix;
+ function mergeNsAndName(prefix, localName) {
+ return lang_1.isPresent(prefix) ? "@" + prefix + ":" + localName : localName;
+ }
+ exports.mergeNsAndName = mergeNsAndName;
+ //# sourceMappingURL=html_tags.js.map
+
+/***/ },
+/* 55 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var lang_1 = __webpack_require__(3);
+ var exceptions_1 = __webpack_require__(8);
+ var o = __webpack_require__(10);
+ var _SINGLE_QUOTE_ESCAPE_STRING_RE = /'|\\|\n|\r|\$/g;
+ exports.CATCH_ERROR_VAR = o.variable('error');
+ exports.CATCH_STACK_VAR = o.variable('stack');
+ var OutputEmitter = (function () {
+ function OutputEmitter() {
+ }
+ return OutputEmitter;
+ }());
+ exports.OutputEmitter = OutputEmitter;
+ var _EmittedLine = (function () {
+ function _EmittedLine(indent) {
+ this.indent = indent;
+ this.parts = [];
+ }
+ return _EmittedLine;
+ }());
+ var EmitterVisitorContext = (function () {
+ function EmitterVisitorContext(_exportedVars, _indent) {
+ this._exportedVars = _exportedVars;
+ this._indent = _indent;
+ this._classes = [];
+ this._lines = [new _EmittedLine(_indent)];
+ }
+ EmitterVisitorContext.createRoot = function (exportedVars) {
+ return new EmitterVisitorContext(exportedVars, 0);
+ };
+ Object.defineProperty(EmitterVisitorContext.prototype, "_currentLine", {
+ get: function () { return this._lines[this._lines.length - 1]; },
+ enumerable: true,
+ configurable: true
+ });
+ EmitterVisitorContext.prototype.isExportedVar = function (varName) { return this._exportedVars.indexOf(varName) !== -1; };
+ EmitterVisitorContext.prototype.println = function (lastPart) {
+ if (lastPart === void 0) { lastPart = ''; }
+ this.print(lastPart, true);
+ };
+ EmitterVisitorContext.prototype.lineIsEmpty = function () { return this._currentLine.parts.length === 0; };
+ EmitterVisitorContext.prototype.print = function (part, newLine) {
+ if (newLine === void 0) { newLine = false; }
+ if (part.length > 0) {
+ this._currentLine.parts.push(part);
+ }
+ if (newLine) {
+ this._lines.push(new _EmittedLine(this._indent));
+ }
+ };
+ EmitterVisitorContext.prototype.removeEmptyLastLine = function () {
+ if (this.lineIsEmpty()) {
+ this._lines.pop();
+ }
+ };
+ EmitterVisitorContext.prototype.incIndent = function () {
+ this._indent++;
+ this._currentLine.indent = this._indent;
+ };
+ EmitterVisitorContext.prototype.decIndent = function () {
+ this._indent--;
+ this._currentLine.indent = this._indent;
+ };
+ EmitterVisitorContext.prototype.pushClass = function (clazz) { this._classes.push(clazz); };
+ EmitterVisitorContext.prototype.popClass = function () { return this._classes.pop(); };
+ Object.defineProperty(EmitterVisitorContext.prototype, "currentClass", {
+ get: function () {
+ return this._classes.length > 0 ? this._classes[this._classes.length - 1] : null;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ EmitterVisitorContext.prototype.toSource = function () {
+ var lines = this._lines;
+ if (lines[lines.length - 1].parts.length === 0) {
+ lines = lines.slice(0, lines.length - 1);
+ }
+ return lines.map(function (line) {
+ if (line.parts.length > 0) {
+ return _createIndent(line.indent) + line.parts.join('');
+ }
+ else {
+ return '';
+ }
+ })
+ .join('\n');
+ };
+ return EmitterVisitorContext;
+ }());
+ exports.EmitterVisitorContext = EmitterVisitorContext;
+ var AbstractEmitterVisitor = (function () {
+ function AbstractEmitterVisitor(_escapeDollarInStrings) {
+ this._escapeDollarInStrings = _escapeDollarInStrings;
+ }
+ AbstractEmitterVisitor.prototype.visitExpressionStmt = function (stmt, ctx) {
+ stmt.expr.visitExpression(this, ctx);
+ ctx.println(';');
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitReturnStmt = function (stmt, ctx) {
+ ctx.print("return ");
+ stmt.value.visitExpression(this, ctx);
+ ctx.println(';');
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitIfStmt = function (stmt, ctx) {
+ ctx.print("if (");
+ stmt.condition.visitExpression(this, ctx);
+ ctx.print(") {");
+ var hasElseCase = lang_1.isPresent(stmt.falseCase) && stmt.falseCase.length > 0;
+ if (stmt.trueCase.length <= 1 && !hasElseCase) {
+ ctx.print(" ");
+ this.visitAllStatements(stmt.trueCase, ctx);
+ ctx.removeEmptyLastLine();
+ ctx.print(" ");
+ }
+ else {
+ ctx.println();
+ ctx.incIndent();
+ this.visitAllStatements(stmt.trueCase, ctx);
+ ctx.decIndent();
+ if (hasElseCase) {
+ ctx.println("} else {");
+ ctx.incIndent();
+ this.visitAllStatements(stmt.falseCase, ctx);
+ ctx.decIndent();
+ }
+ }
+ ctx.println("}");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitThrowStmt = function (stmt, ctx) {
+ ctx.print("throw ");
+ stmt.error.visitExpression(this, ctx);
+ ctx.println(";");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitCommentStmt = function (stmt, ctx) {
+ var lines = stmt.comment.split('\n');
+ lines.forEach(function (line) { ctx.println("// " + line); });
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitWriteVarExpr = function (expr, ctx) {
+ var lineWasEmpty = ctx.lineIsEmpty();
+ if (!lineWasEmpty) {
+ ctx.print('(');
+ }
+ ctx.print(expr.name + " = ");
+ expr.value.visitExpression(this, ctx);
+ if (!lineWasEmpty) {
+ ctx.print(')');
+ }
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitWriteKeyExpr = function (expr, ctx) {
+ var lineWasEmpty = ctx.lineIsEmpty();
+ if (!lineWasEmpty) {
+ ctx.print('(');
+ }
+ expr.receiver.visitExpression(this, ctx);
+ ctx.print("[");
+ expr.index.visitExpression(this, ctx);
+ ctx.print("] = ");
+ expr.value.visitExpression(this, ctx);
+ if (!lineWasEmpty) {
+ ctx.print(')');
+ }
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitWritePropExpr = function (expr, ctx) {
+ var lineWasEmpty = ctx.lineIsEmpty();
+ if (!lineWasEmpty) {
+ ctx.print('(');
+ }
+ expr.receiver.visitExpression(this, ctx);
+ ctx.print("." + expr.name + " = ");
+ expr.value.visitExpression(this, ctx);
+ if (!lineWasEmpty) {
+ ctx.print(')');
+ }
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitInvokeMethodExpr = function (expr, ctx) {
+ expr.receiver.visitExpression(this, ctx);
+ var name = expr.name;
+ if (lang_1.isPresent(expr.builtin)) {
+ name = this.getBuiltinMethodName(expr.builtin);
+ if (lang_1.isBlank(name)) {
+ // some builtins just mean to skip the call.
+ // e.g. `bind` in Dart.
+ return null;
+ }
+ }
+ ctx.print("." + name + "(");
+ this.visitAllExpressions(expr.args, ctx, ",");
+ ctx.print(")");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitInvokeFunctionExpr = function (expr, ctx) {
+ expr.fn.visitExpression(this, ctx);
+ ctx.print("(");
+ this.visitAllExpressions(expr.args, ctx, ',');
+ ctx.print(")");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitReadVarExpr = function (ast, ctx) {
+ var varName = ast.name;
+ if (lang_1.isPresent(ast.builtin)) {
+ switch (ast.builtin) {
+ case o.BuiltinVar.Super:
+ varName = 'super';
+ break;
+ case o.BuiltinVar.This:
+ varName = 'this';
+ break;
+ case o.BuiltinVar.CatchError:
+ varName = exports.CATCH_ERROR_VAR.name;
+ break;
+ case o.BuiltinVar.CatchStack:
+ varName = exports.CATCH_STACK_VAR.name;
+ break;
+ default:
+ throw new exceptions_1.BaseException("Unknown builtin variable " + ast.builtin);
+ }
+ }
+ ctx.print(varName);
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitInstantiateExpr = function (ast, ctx) {
+ ctx.print("new ");
+ ast.classExpr.visitExpression(this, ctx);
+ ctx.print("(");
+ this.visitAllExpressions(ast.args, ctx, ',');
+ ctx.print(")");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitLiteralExpr = function (ast, ctx) {
+ var value = ast.value;
+ if (lang_1.isString(value)) {
+ ctx.print(escapeSingleQuoteString(value, this._escapeDollarInStrings));
+ }
+ else if (lang_1.isBlank(value)) {
+ ctx.print('null');
+ }
+ else {
+ ctx.print("" + value);
+ }
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitConditionalExpr = function (ast, ctx) {
+ ctx.print("(");
+ ast.condition.visitExpression(this, ctx);
+ ctx.print('? ');
+ ast.trueCase.visitExpression(this, ctx);
+ ctx.print(': ');
+ ast.falseCase.visitExpression(this, ctx);
+ ctx.print(")");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitNotExpr = function (ast, ctx) {
+ ctx.print('!');
+ ast.condition.visitExpression(this, ctx);
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitBinaryOperatorExpr = function (ast, ctx) {
+ var opStr;
+ switch (ast.operator) {
+ case o.BinaryOperator.Equals:
+ opStr = '==';
+ break;
+ case o.BinaryOperator.Identical:
+ opStr = '===';
+ break;
+ case o.BinaryOperator.NotEquals:
+ opStr = '!=';
+ break;
+ case o.BinaryOperator.NotIdentical:
+ opStr = '!==';
+ break;
+ case o.BinaryOperator.And:
+ opStr = '&&';
+ break;
+ case o.BinaryOperator.Or:
+ opStr = '||';
+ break;
+ case o.BinaryOperator.Plus:
+ opStr = '+';
+ break;
+ case o.BinaryOperator.Minus:
+ opStr = '-';
+ break;
+ case o.BinaryOperator.Divide:
+ opStr = '/';
+ break;
+ case o.BinaryOperator.Multiply:
+ opStr = '*';
+ break;
+ case o.BinaryOperator.Modulo:
+ opStr = '%';
+ break;
+ case o.BinaryOperator.Lower:
+ opStr = '<';
+ break;
+ case o.BinaryOperator.LowerEquals:
+ opStr = '<=';
+ break;
+ case o.BinaryOperator.Bigger:
+ opStr = '>';
+ break;
+ case o.BinaryOperator.BiggerEquals:
+ opStr = '>=';
+ break;
+ default:
+ throw new exceptions_1.BaseException("Unknown operator " + ast.operator);
+ }
+ ctx.print("(");
+ ast.lhs.visitExpression(this, ctx);
+ ctx.print(" " + opStr + " ");
+ ast.rhs.visitExpression(this, ctx);
+ ctx.print(")");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitReadPropExpr = function (ast, ctx) {
+ ast.receiver.visitExpression(this, ctx);
+ ctx.print(".");
+ ctx.print(ast.name);
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitReadKeyExpr = function (ast, ctx) {
+ ast.receiver.visitExpression(this, ctx);
+ ctx.print("[");
+ ast.index.visitExpression(this, ctx);
+ ctx.print("]");
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitLiteralArrayExpr = function (ast, ctx) {
+ var useNewLine = ast.entries.length > 1;
+ ctx.print("[", useNewLine);
+ ctx.incIndent();
+ this.visitAllExpressions(ast.entries, ctx, ',', useNewLine);
+ ctx.decIndent();
+ ctx.print("]", useNewLine);
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitLiteralMapExpr = function (ast, ctx) {
+ var _this = this;
+ var useNewLine = ast.entries.length > 1;
+ ctx.print("{", useNewLine);
+ ctx.incIndent();
+ this.visitAllObjects(function (entry) {
+ ctx.print(escapeSingleQuoteString(entry[0], _this._escapeDollarInStrings) + ": ");
+ entry[1].visitExpression(_this, ctx);
+ }, ast.entries, ctx, ',', useNewLine);
+ ctx.decIndent();
+ ctx.print("}", useNewLine);
+ return null;
+ };
+ AbstractEmitterVisitor.prototype.visitAllExpressions = function (expressions, ctx, separator, newLine) {
+ var _this = this;
+ if (newLine === void 0) { newLine = false; }
+ this.visitAllObjects(function (expr) { return expr.visitExpression(_this, ctx); }, expressions, ctx, separator, newLine);
+ };
+ AbstractEmitterVisitor.prototype.visitAllObjects = function (handler, expressions, ctx, separator, newLine) {
+ if (newLine === void 0) { newLine = false; }
+ for (var i = 0; i < expressions.length; i++) {
+ if (i > 0) {
+ ctx.print(separator, newLine);
+ }
+ handler(expressions[i]);
+ }
+ if (newLine) {
+ ctx.println();
+ }
+ };
+ AbstractEmitterVisitor.prototype.visitAllStatements = function (statements, ctx) {
+ var _this = this;
+ statements.forEach(function (stmt) { return stmt.visitStatement(_this, ctx); });
+ };
+ return AbstractEmitterVisitor;
+ }());
+ exports.AbstractEmitterVisitor = AbstractEmitterVisitor;
+ function escapeSingleQuoteString(input, escapeDollar) {
+ if (lang_1.isBlank(input)) {
+ return null;
+ }
+ var body = lang_1.StringWrapper.replaceAllMapped(input, _SINGLE_QUOTE_ESCAPE_STRING_RE, function (match) {
+ if (match[0] == '$') {
+ return escapeDollar ? '\\$' : '$';
+ }
+ else if (match[0] == '\n') {
+ return '\\n';
+ }
+ else if (match[0] == '\r') {
+ return '\\r';
+ }
+ else {
+ return "\\" + match[0];
+ }
+ });
+ return "'" + body + "'";
+ }
+ exports.escapeSingleQuoteString = escapeSingleQuoteString;
+ function _createIndent(count) {
+ var res = '';
+ for (var i = 0; i < count; i++) {
+ res += ' ';
+ }
+ return res;
+ }
+ //# sourceMappingURL=abstract_emitter.js.map
+
+/***/ },
+/* 56 */
+/***/ function(module, exports) {
+
+ "use strict";
+ var ParseLocation = (function () {
+ function ParseLocation(file, offset, line, col) {
+ this.file = file;
+ this.offset = offset;
+ this.line = line;
+ this.col = col;
+ }
+ ParseLocation.prototype.toString = function () { return this.file.url + "@" + this.line + ":" + this.col; };
+ return ParseLocation;
+ }());
+ exports.ParseLocation = ParseLocation;
+ var ParseSourceFile = (function () {
+ function ParseSourceFile(content, url) {
+ this.content = content;
+ this.url = url;
+ }
+ return ParseSourceFile;
+ }());
+ exports.ParseSourceFile = ParseSourceFile;
+ var ParseSourceSpan = (function () {
+ function ParseSourceSpan(start, end) {
+ this.start = start;
+ this.end = end;
+ }
+ ParseSourceSpan.prototype.toString = function () {
+ return this.start.file.content.substring(this.start.offset, this.end.offset);
+ };
+ return ParseSourceSpan;
+ }());
+ exports.ParseSourceSpan = ParseSourceSpan;
+ (function (ParseErrorLevel) {
+ ParseErrorLevel[ParseErrorLevel["WARNING"] = 0] = "WARNING";
+ ParseErrorLevel[ParseErrorLevel["FATAL"] = 1] = "FATAL";
+ })(exports.ParseErrorLevel || (exports.ParseErrorLevel = {}));
+ var ParseErrorLevel = exports.ParseErrorLevel;
+ var ParseError = (function () {
+ function ParseError(span, msg, level) {
+ if (level === void 0) { level = ParseErrorLevel.FATAL; }
+ this.span = span;
+ this.msg = msg;
+ this.level = level;
+ }
+ ParseError.prototype.toString = function () {
+ var source = this.span.start.file.content;
+ var ctxStart = this.span.start.offset;
+ if (ctxStart > source.length - 1) {
+ ctxStart = source.length - 1;
+ }
+ var ctxEnd = ctxStart;
+ var ctxLen = 0;
+ var ctxLines = 0;
+ while (ctxLen < 100 && ctxStart > 0) {
+ ctxStart--;
+ ctxLen++;
+ if (source[ctxStart] == "\n") {
+ if (++ctxLines == 3) {
+ break;
+ }
+ }
+ }
+ ctxLen = 0;
+ ctxLines = 0;
+ while (ctxLen < 100 && ctxEnd < source.length - 1) {
+ ctxEnd++;
+ ctxLen++;
+ if (source[ctxEnd] == "\n") {
+ if (++ctxLines == 3) {
+ break;
+ }
+ }
+ }
+ var context = source.substring(ctxStart, this.span.start.offset) + '[ERROR ->]' +
+ source.substring(this.span.start.offset, ctxEnd + 1);
+ return this.msg + " (\"" + context + "\"): " + this.span.start;
+ };
+ return ParseError;
+ }());
+ exports.ParseError = ParseError;
+ //# sourceMappingURL=parse_util.js.map
+
+/***/ },
+/* 57 */
+/***/ function(module, exports) {
+
+ "use strict";
+ var ElementSchemaRegistry = (function () {
+ function ElementSchemaRegistry() {
+ }
+ return ElementSchemaRegistry;
+ }());
+ exports.ElementSchemaRegistry = ElementSchemaRegistry;
+ //# sourceMappingURL=element_schema_registry.js.map
+
+/***/ },
+/* 58 */,
+/* 59 */,
+/* 60 */,
+/* 61 */,
+/* 62 */,
+/* 63 */,
+/* 64 */,
+/* 65 */,
+/* 66 */,
+/* 67 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var core_1 = __webpack_require__(1);
+ var core_private_1 = __webpack_require__(115);
+ var common_1 = __webpack_require__(6);
+ var dom_sanitization_service_1 = __webpack_require__(214);
+ var lang_1 = __webpack_require__(12);
+ var browser_adapter_1 = __webpack_require__(118);
+ var testability_1 = __webpack_require__(411);
+ var dom_adapter_1 = __webpack_require__(15);
+ var dom_tokens_1 = __webpack_require__(68);
+ var event_manager_1 = __webpack_require__(35);
+ var dom_renderer_1 = __webpack_require__(207);
+ var shared_styles_host_1 = __webpack_require__(120);
+ var key_events_1 = __webpack_require__(417);
+ var ng_probe_1 = __webpack_require__(119);
+ var dom_events_1 = __webpack_require__(208);
+ var hammer_gestures_1 = __webpack_require__(209);
+ var shared_styles_host_2 = __webpack_require__(120);
+ var animation_builder_1 = __webpack_require__(116);
+ var browser_details_1 = __webpack_require__(117);
+ var title_1 = __webpack_require__(412);
+ exports.Title = title_1.Title;
+ var browser_adapter_2 = __webpack_require__(118);
+ exports.BrowserDomAdapter = browser_adapter_2.BrowserDomAdapter;
+ var tools_1 = __webpack_require__(414);
+ exports.enableDebugTools = tools_1.enableDebugTools;
+ exports.disableDebugTools = tools_1.disableDebugTools;
+ var by_1 = __webpack_require__(415);
+ exports.By = by_1.By;
+ exports.BROWSER_PLATFORM_MARKER =
+ /*@ts2dart_const*/ new core_1.OpaqueToken('BrowserPlatformMarker');
+ /**
+ * A set of providers to initialize the Angular platform in a web browser.
+ *
+ * Used automatically by `bootstrap`, or can be passed to {@link platform}.
+ */
+ exports.BROWSER_PROVIDERS = [
+ /*@ts2dart_Provider*/ { provide: exports.BROWSER_PLATFORM_MARKER, useValue: true },
+ core_1.PLATFORM_COMMON_PROVIDERS,
+ /*@ts2dart_Provider*/ { provide: core_1.PLATFORM_INITIALIZER, useValue: initDomAdapter, multi: true },
+ ];
+ function _exceptionHandler() {
+ // !IS_DART is required because we must rethrow exceptions in JS,
+ // but must not rethrow exceptions in Dart
+ return new core_1.ExceptionHandler(dom_adapter_1.getDOM(), !lang_1.IS_DART);
+ }
+ function _document() {
+ return dom_adapter_1.getDOM().defaultDoc();
+ }
+ exports.BROWSER_SANITIZATION_PROVIDERS = [
+ /* @ts2dart_Provider */ { provide: core_private_1.SanitizationService, useExisting: dom_sanitization_service_1.DomSanitizationService },
+ /* @ts2dart_Provider */ { provide: dom_sanitization_service_1.DomSanitizationService, useClass: dom_sanitization_service_1.DomSanitizationServiceImpl },
+ ];
+ /**
+ * A set of providers to initialize an Angular application in a web browser.
+ *
+ * Used automatically by `bootstrap`, or can be passed to {@link PlatformRef.application}.
+ */
+ exports.BROWSER_APP_COMMON_PROVIDERS =
+ /*@ts2dart_const*/ [
+ core_1.APPLICATION_COMMON_PROVIDERS,
+ common_1.FORM_PROVIDERS,
+ exports.BROWSER_SANITIZATION_PROVIDERS,
+ /* @ts2dart_Provider */ { provide: core_1.PLATFORM_PIPES, useValue: common_1.COMMON_PIPES, multi: true },
+ /* @ts2dart_Provider */ { provide: core_1.PLATFORM_DIRECTIVES, useValue: common_1.COMMON_DIRECTIVES, multi: true },
+ /* @ts2dart_Provider */ { provide: core_1.ExceptionHandler, useFactory: _exceptionHandler, deps: [] },
+ /* @ts2dart_Provider */ { provide: dom_tokens_1.DOCUMENT, useFactory: _document, deps: [] },
+ /* @ts2dart_Provider */ { provide: event_manager_1.EVENT_MANAGER_PLUGINS, useClass: dom_events_1.DomEventsPlugin, multi: true },
+ /* @ts2dart_Provider */ { provide: event_manager_1.EVENT_MANAGER_PLUGINS, useClass: key_events_1.KeyEventsPlugin, multi: true },
+ /* @ts2dart_Provider */ { provide: event_manager_1.EVENT_MANAGER_PLUGINS, useClass: hammer_gestures_1.HammerGesturesPlugin, multi: true },
+ /* @ts2dart_Provider */ { provide: hammer_gestures_1.HAMMER_GESTURE_CONFIG, useClass: hammer_gestures_1.HammerGestureConfig },
+ /* @ts2dart_Provider */ { provide: dom_renderer_1.DomRootRenderer, useClass: dom_renderer_1.DomRootRenderer_ },
+ /* @ts2dart_Provider */ { provide: core_1.RootRenderer, useExisting: dom_renderer_1.DomRootRenderer },
+ /* @ts2dart_Provider */ { provide: shared_styles_host_1.SharedStylesHost, useExisting: shared_styles_host_2.DomSharedStylesHost },
+ shared_styles_host_2.DomSharedStylesHost,
+ core_1.Testability,
+ browser_details_1.BrowserDetails,
+ animation_builder_1.AnimationBuilder,
+ event_manager_1.EventManager,
+ ng_probe_1.ELEMENT_PROBE_PROVIDERS
+ ];
+ var hammer_gestures_2 = __webpack_require__(209);
+ exports.HAMMER_GESTURE_CONFIG = hammer_gestures_2.HAMMER_GESTURE_CONFIG;
+ exports.HammerGestureConfig = hammer_gestures_2.HammerGestureConfig;
+ function initDomAdapter() {
+ browser_adapter_1.BrowserDomAdapter.makeCurrent();
+ core_private_1.wtfInit();
+ testability_1.BrowserGetTestability.init();
+ }
+ exports.initDomAdapter = initDomAdapter;
+ //# sourceMappingURL=browser_common.js.map
+
+/***/ },
+/* 68 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var core_1 = __webpack_require__(1);
+ /**
+ * A DI Token representing the main rendering context. In a browser this is the DOM Document.
+ *
+ * Note: Document might not be available in the Application Context when Application and Rendering
+ * Contexts are not the same (e.g. when running the application into a Web Worker).
+ */
+ exports.DOCUMENT = new core_1.OpaqueToken('DocumentToken');
+ //# sourceMappingURL=dom_tokens.js.map
+
+/***/ },
+/* 69 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+ };
+ var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+ };
+ var core_1 = __webpack_require__(1);
+ var common_1 = __webpack_require__(6);
+ var date_formatter_1 = __webpack_require__(430);
+ var FORMAT_DAY = 'DD';
+ var FORMAT_MONTH = 'MMMM';
+ var FORMAT_YEAR = 'YYYY';
+ var FORMAT_DAY_HEADER = 'dd';
+ var FORMAT_DAY_TITLE = 'MMMM YYYY';
+ var FORMAT_MONTH_TITLE = 'YYYY';
+ var DATEPICKER_MODE = 'day';
+ var MIN_MODE = 'day';
+ var MAX_MODE = 'year';
+ var SHOW_WEEKS = true;
+ var ONLY_CURRENT_MONTH = false;
+ var STARTING_DAY = 0;
+ var YEAR_RANGE = 20;
+ // const MIN_DATE:Date = void 0;
+ // const MAX_DATE:Date = void 0;
+ var SHORTCUT_PROPAGATION = false;
+ // const DAYS_IN_MONTH = [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+ /*
+ const KEYS = {
+ 13: 'enter',
+ 32: 'space',
+ 33: 'pageup',
+ 34: 'pagedown',
+ 35: 'end',
+ 36: 'home',
+ 37: 'left',
+ 38: 'up',
+ 39: 'right',
+ 40: 'down'
+ };
+ */
+ var DatePickerInnerComponent = (function () {
+ function DatePickerInnerComponent() {
+ this.stepDay = {};
+ this.stepMonth = {};
+ this.stepYear = {};
+ this.modes = ['day', 'month', 'year'];
+ this.dateFormatter = new date_formatter_1.DateFormatter();
+ this.update = new core_1.EventEmitter(false);
+ }
+ Object.defineProperty(DatePickerInnerComponent.prototype, "activeDate", {
+ get: function () {
+ return this._activeDate;
+ },
+ set: function (value) {
+ this._activeDate = value;
+ this.refreshView();
+ },
+ enumerable: true,
+ configurable: true
+ });
+ // todo: add formatter value to Date object
+ DatePickerInnerComponent.prototype.ngOnInit = function () {
+ this.formatDay = this.formatDay || FORMAT_DAY;
+ this.formatMonth = this.formatMonth || FORMAT_MONTH;
+ this.formatYear = this.formatYear || FORMAT_YEAR;
+ this.formatDayHeader = this.formatDayHeader || FORMAT_DAY_HEADER;
+ this.formatDayTitle = this.formatDayTitle || FORMAT_DAY_TITLE;
+ this.formatMonthTitle = this.formatMonthTitle || FORMAT_MONTH_TITLE;
+ this.showWeeks = (this.showWeeks === undefined
+ ? SHOW_WEEKS
+ : this.showWeeks);
+ this.onlyCurrentMonth = (this.onlyCurrentMonth === undefined
+ ? ONLY_CURRENT_MONTH
+ : this.onlyCurrentMonth);
+ this.startingDay = this.startingDay || STARTING_DAY;
+ this.yearRange = this.yearRange || YEAR_RANGE;
+ this.shortcutPropagation = this.shortcutPropagation || SHORTCUT_PROPAGATION;
+ this.datepickerMode = this.datepickerMode || DATEPICKER_MODE;
+ this.minMode = this.minMode || MIN_MODE;
+ this.maxMode = this.maxMode || MAX_MODE;
+ // todo: use date for unique value
+ this.uniqueId = 'datepicker-' + '-' + Math.floor(Math.random() * 10000);
+ if (this.initDate) {
+ this.activeDate = this.initDate;
+ this.selectedDate = new Date(this.activeDate.valueOf());
+ this.update.emit(this.activeDate);
+ }
+ else if (this.activeDate === undefined) {
+ this.activeDate = new Date();
+ }
+ this.refreshView();
+ };
+ DatePickerInnerComponent.prototype.setCompareHandler = function (handler, type) {
+ if (type === 'day') {
+ this.compareHandlerDay = handler;
+ }
+ if (type === 'month') {
+ this.compareHandlerMonth = handler;
+ }
+ if (type === 'year') {
+ this.compareHandlerYear = handler;
+ }
+ };
+ DatePickerInnerComponent.prototype.compare = function (date1, date2) {
+ if (date1 === undefined || date2 === undefined) {
+ return undefined;
+ }
+ if (this.datepickerMode === 'day' && this.compareHandlerDay) {
+ return this.compareHandlerDay(date1, date2);
+ }
+ if (this.datepickerMode === 'month' && this.compareHandlerMonth) {
+ return this.compareHandlerMonth(date1, date2);
+ }
+ if (this.datepickerMode === 'year' && this.compareHandlerYear) {
+ return this.compareHandlerYear(date1, date2);
+ }
+ return void 0;
+ };
+ DatePickerInnerComponent.prototype.setRefreshViewHandler = function (handler, type) {
+ if (type === 'day') {
+ this.refreshViewHandlerDay = handler;
+ }
+ if (type === 'month') {
+ this.refreshViewHandlerMonth = handler;
+ }
+ if (type === 'year') {
+ this.refreshViewHandlerYear = handler;
+ }
+ };
+ DatePickerInnerComponent.prototype.refreshView = function () {
+ if (this.datepickerMode === 'day' && this.refreshViewHandlerDay) {
+ this.refreshViewHandlerDay();
+ }
+ if (this.datepickerMode === 'month' && this.refreshViewHandlerMonth) {
+ this.refreshViewHandlerMonth();
+ }
+ if (this.datepickerMode === 'year' && this.refreshViewHandlerYear) {
+ this.refreshViewHandlerYear();
+ }
+ };
+ DatePickerInnerComponent.prototype.dateFilter = function (date, format) {
+ return this.dateFormatter.format(date, format);
+ };
+ DatePickerInnerComponent.prototype.isActive = function (dateObject) {
+ if (this.compare(dateObject.date, this.activeDate) === 0) {
+ this.activeDateId = dateObject.uid;
+ return true;
+ }
+ return false;
+ };
+ DatePickerInnerComponent.prototype.createDateObject = function (date, format) {
+ var dateObject = {};
+ dateObject.date = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+ dateObject.label = this.dateFilter(date, format);
+ dateObject.selected = this.compare(date, this.selectedDate) === 0;
+ dateObject.disabled = this.isDisabled(date);
+ dateObject.current = this.compare(date, new Date()) === 0;
+ dateObject.customClass = this.getCustomClassForDate(dateObject.date);
+ return dateObject;
+ };
+ DatePickerInnerComponent.prototype.split = function (arr, size) {
+ var arrays = [];
+ while (arr.length > 0) {
+ arrays.push(arr.splice(0, size));
+ }
+ return arrays;
+ };
+ // Fix a hard-reproducible bug with timezones
+ // The bug depends on OS, browser, current timezone and current date
+ // i.e.
+ // var date = new Date(2014, 0, 1);
+ // console.log(date.getFullYear(), date.getMonth(), date.getDate(),
+ // date.getHours()); can result in "2013 11 31 23" because of the bug.
+ DatePickerInnerComponent.prototype.fixTimeZone = function (date) {
+ var hours = date.getHours();
+ return new Date(date.getFullYear(), date.getMonth(), date.getDate(), hours === 23 ? hours + 2 : 0);
+ };
+ DatePickerInnerComponent.prototype.select = function (date) {
+ if (this.datepickerMode === this.minMode) {
+ if (!this.activeDate) {
+ this.activeDate = new Date(0, 0, 0, 0, 0, 0, 0);
+ }
+ this.activeDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+ }
+ else {
+ this.activeDate = date;
+ this.datepickerMode = this.modes[this.modes.indexOf(this.datepickerMode) - 1];
+ }
+ this.selectedDate = new Date(this.activeDate.valueOf());
+ this.update.emit(this.activeDate);
+ this.refreshView();
+ };
+ DatePickerInnerComponent.prototype.move = function (direction) {
+ var expectedStep;
+ if (this.datepickerMode === 'day') {
+ expectedStep = this.stepDay;
+ }
+ if (this.datepickerMode === 'month') {
+ expectedStep = this.stepMonth;
+ }
+ if (this.datepickerMode === 'year') {
+ expectedStep = this.stepYear;
+ }
+ if (expectedStep) {
+ var year = this.activeDate.getFullYear() + direction * (expectedStep.years || 0);
+ var month = this.activeDate.getMonth() + direction * (expectedStep.months || 0);
+ this.activeDate = new Date(year, month, 1);
+ this.refreshView();
+ }
+ };
+ DatePickerInnerComponent.prototype.toggleMode = function (direction) {
+ direction = direction || 1;
+ if ((this.datepickerMode === this.maxMode && direction === 1) ||
+ (this.datepickerMode === this.minMode && direction === -1)) {
+ return;
+ }
+ this.datepickerMode = this.modes[this.modes.indexOf(this.datepickerMode) + direction];
+ this.refreshView();
+ };
+ DatePickerInnerComponent.prototype.getCustomClassForDate = function (date) {
+ var _this = this;
+ if (!this.customClass) {
+ return '';
+ }
+ // todo: build a hash of custom classes, it will work faster
+ var customClassObject = this.customClass
+ .find(function (customClass) {
+ return customClass.date.valueOf() === date.valueOf() &&
+ customClass.mode === _this.datepickerMode;
+ }, this);
+ return customClassObject === undefined ? '' : customClassObject.clazz;
+ };
+ DatePickerInnerComponent.prototype.isDisabled = function (date) {
+ // todo: implement dateDisabled attribute
+ return ((this.minDate && this.compare(date, this.minDate) < 0) ||
+ (this.maxDate && this.compare(date, this.maxDate) > 0));
+ };
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "datepickerMode", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Number)
+ ], DatePickerInnerComponent.prototype, "startingDay", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Number)
+ ], DatePickerInnerComponent.prototype, "yearRange", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Date)
+ ], DatePickerInnerComponent.prototype, "minDate", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Date)
+ ], DatePickerInnerComponent.prototype, "maxDate", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "minMode", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "maxMode", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Boolean)
+ ], DatePickerInnerComponent.prototype, "showWeeks", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "formatDay", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "formatMonth", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "formatYear", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "formatDayHeader", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "formatDayTitle", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DatePickerInnerComponent.prototype, "formatMonthTitle", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Boolean)
+ ], DatePickerInnerComponent.prototype, "onlyCurrentMonth", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Boolean)
+ ], DatePickerInnerComponent.prototype, "shortcutPropagation", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Array)
+ ], DatePickerInnerComponent.prototype, "customClass", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Object)
+ ], DatePickerInnerComponent.prototype, "dateDisabled", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Date)
+ ], DatePickerInnerComponent.prototype, "initDate", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Date)
+ ], DatePickerInnerComponent.prototype, "activeDate", null);
+ DatePickerInnerComponent = __decorate([
+ core_1.Component({
+ selector: 'datepicker-inner',
+ events: ['update'],
+ template: "\n \n \n
\n ",
+ directives: [common_1.FORM_DIRECTIVES, common_1.CORE_DIRECTIVES, common_1.NgClass, common_1.NgModel]
+ }),
+ __metadata('design:paramtypes', [])
+ ], DatePickerInnerComponent);
+ return DatePickerInnerComponent;
+ }());
+ exports.DatePickerInnerComponent = DatePickerInnerComponent;
+
+
+/***/ },
+/* 70 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+ };
+ var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+ };
+ var core_1 = __webpack_require__(1);
+ var dropdown_service_1 = __webpack_require__(434);
+ var DropdownDirective = (function () {
+ function DropdownDirective(el) {
+ this.onToggle = new core_1.EventEmitter(false);
+ this.isOpenChange = new core_1.EventEmitter(false);
+ this.addClass = true;
+ // @Query('dropdownMenu', {descendants: false})
+ // dropdownMenuList:QueryList) {
+ this.el = el;
+ // todo: bind to route change event
+ }
+ Object.defineProperty(DropdownDirective.prototype, "isOpen", {
+ get: function () {
+ return this._isOpen;
+ },
+ set: function (value) {
+ this._isOpen = !!value;
+ // todo: implement after porting position
+ // if (this.appendToBody && this.menuEl) {
+ //
+ // }
+ // todo: $animate open<->close transitions, as soon as ng2Animate will be
+ // ready
+ if (this.isOpen) {
+ this.focusToggleElement();
+ dropdown_service_1.dropdownService.open(this);
+ }
+ else {
+ dropdown_service_1.dropdownService.close(this);
+ this.selectedOption = void 0;
+ }
+ this.onToggle.emit(this.isOpen);
+ this.isOpenChange.emit(this.isOpen);
+ // todo: implement call to setIsOpen if set and function
+ },
+ enumerable: true,
+ configurable: true
+ });
+ DropdownDirective.prototype.ngOnInit = function () {
+ this.autoClose = this.autoClose || dropdown_service_1.NONINPUT;
+ if (this.isOpen) {
+ }
+ };
+ DropdownDirective.prototype.ngOnDestroy = function () {
+ if (this.appendToBody && this.menuEl) {
+ this.menuEl.nativeElement.remove();
+ }
+ };
+ Object.defineProperty(DropdownDirective.prototype, "dropDownMenu", {
+ set: function (dropdownMenu) {
+ // init drop down menu
+ this.menuEl = dropdownMenu.el;
+ if (this.appendToBody) {
+ window.document.body.appendChild(this.menuEl.nativeElement);
+ }
+ },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(DropdownDirective.prototype, "dropDownToggle", {
+ set: function (dropdownToggle) {
+ // init toggle element
+ this.toggleEl = dropdownToggle.el;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ DropdownDirective.prototype.toggle = function (open) {
+ return this.isOpen = arguments.length ? !!open : !this.isOpen;
+ };
+ DropdownDirective.prototype.focusDropdownEntry = function (keyCode) {
+ // If append to body is used.
+ var hostEl = this.menuEl ?
+ this.menuEl.nativeElement :
+ this.el.nativeElement.getElementsByTagName('ul')[0];
+ if (!hostEl) {
+ // todo: throw exception?
+ return;
+ }
+ var elems = hostEl.getElementsByTagName('a');
+ if (!elems || !elems.length) {
+ // todo: throw exception?
+ return;
+ }
+ // todo: use parseInt to detect isNumber?
+ // todo: or implement selectedOption as a get\set pair with parseInt on set
+ switch (keyCode) {
+ case (40):
+ if (typeof this.selectedOption !== 'number') {
+ this.selectedOption = 0;
+ break;
+ }
+ if (this.selectedOption === elems.length - 1) {
+ break;
+ }
+ this.selectedOption++;
+ break;
+ case (38):
+ if (typeof this.selectedOption !== 'number') {
+ return;
+ }
+ if (this.selectedOption === 0) {
+ // todo: return?
+ break;
+ }
+ this.selectedOption--;
+ break;
+ default:
+ break;
+ }
+ elems[this.selectedOption].focus();
+ };
+ DropdownDirective.prototype.focusToggleElement = function () {
+ if (this.toggleEl) {
+ this.toggleEl.nativeElement.focus();
+ }
+ };
+ __decorate([
+ core_1.HostBinding('class.open'),
+ core_1.Input(),
+ __metadata('design:type', Boolean)
+ ], DropdownDirective.prototype, "isOpen", null);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', String)
+ ], DropdownDirective.prototype, "autoClose", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Boolean)
+ ], DropdownDirective.prototype, "keyboardNav", void 0);
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Boolean)
+ ], DropdownDirective.prototype, "appendToBody", void 0);
+ __decorate([
+ core_1.Output(),
+ __metadata('design:type', core_1.EventEmitter)
+ ], DropdownDirective.prototype, "onToggle", void 0);
+ __decorate([
+ core_1.Output(),
+ __metadata('design:type', core_1.EventEmitter)
+ ], DropdownDirective.prototype, "isOpenChange", void 0);
+ __decorate([
+ core_1.HostBinding('class.dropdown'),
+ __metadata('design:type', Boolean)
+ ], DropdownDirective.prototype, "addClass", void 0);
+ DropdownDirective = __decorate([
+ core_1.Directive({ selector: '[dropdown]' }),
+ __metadata('design:paramtypes', [core_1.ElementRef])
+ ], DropdownDirective);
+ return DropdownDirective;
+ }());
+ exports.DropdownDirective = DropdownDirective;
+
+
+/***/ },
+/* 71 */
+/***/ function(module, exports) {
+
+ "use strict";
+ var PositionService = (function () {
+ function PositionService() {
+ }
+ /**
+ * Provides read-only equivalent of jQuery's position function:
+ * http://api.jquery.com/position/
+ */
+ PositionService.prototype.position = function (nativeEl) {
+ var elBCR = this.offset(nativeEl);
+ var offsetParentBCR = { top: 0, left: 0 };
+ var offsetParentEl = this.parentOffsetEl(nativeEl);
+ if (offsetParentEl !== this.document) {
+ offsetParentBCR = this.offset(offsetParentEl);
+ offsetParentBCR.top += offsetParentEl.clientTop - offsetParentEl.scrollTop;
+ offsetParentBCR.left += offsetParentEl.clientLeft - offsetParentEl.scrollLeft;
+ }
+ var boundingClientRect = nativeEl.getBoundingClientRect();
+ return {
+ width: boundingClientRect.width || nativeEl.offsetWidth,
+ height: boundingClientRect.height || nativeEl.offsetHeight,
+ top: elBCR.top - offsetParentBCR.top,
+ left: elBCR.left - offsetParentBCR.left
+ };
+ };
+ /**
+ * Provides read-only equivalent of jQuery's offset function:
+ * http://api.jquery.com/offset/
+ */
+ PositionService.prototype.offset = function (nativeEl) {
+ var boundingClientRect = nativeEl.getBoundingClientRect();
+ return {
+ width: boundingClientRect.width || nativeEl.offsetWidth,
+ height: boundingClientRect.height || nativeEl.offsetHeight,
+ top: boundingClientRect.top + (this.window.pageYOffset || this.document.documentElement.scrollTop),
+ left: boundingClientRect.left + (this.window.pageXOffset || this.document.documentElement.scrollLeft)
+ };
+ };
+ /**
+ * Provides coordinates for the targetEl in relation to hostEl
+ */
+ PositionService.prototype.positionElements = function (hostEl, targetEl, positionStr, appendToBody) {
+ var positionStrParts = positionStr.split('-');
+ var pos0 = positionStrParts[0];
+ var pos1 = positionStrParts[1] || 'center';
+ var hostElPos = appendToBody ?
+ this.offset(hostEl) :
+ this.position(hostEl);
+ var targetElWidth = targetEl.offsetWidth;
+ var targetElHeight = targetEl.offsetHeight;
+ var shiftWidth = {
+ center: function () {
+ return hostElPos.left + hostElPos.width / 2 - targetElWidth / 2;
+ },
+ left: function () {
+ return hostElPos.left;
+ },
+ right: function () {
+ return hostElPos.left + hostElPos.width;
+ }
+ };
+ var shiftHeight = {
+ center: function () {
+ return hostElPos.top + hostElPos.height / 2 - targetElHeight / 2;
+ },
+ top: function () {
+ return hostElPos.top;
+ },
+ bottom: function () {
+ return hostElPos.top + hostElPos.height;
+ }
+ };
+ var targetElPos;
+ switch (pos0) {
+ case 'right':
+ targetElPos = {
+ top: shiftHeight[pos1](),
+ left: shiftWidth[pos0]()
+ };
+ break;
+ case 'left':
+ targetElPos = {
+ top: shiftHeight[pos1](),
+ left: hostElPos.left - targetElWidth
+ };
+ break;
+ case 'bottom':
+ targetElPos = {
+ top: shiftHeight[pos0](),
+ left: shiftWidth[pos1]()
+ };
+ break;
+ default:
+ targetElPos = {
+ top: hostElPos.top - targetElHeight,
+ left: shiftWidth[pos1]()
+ };
+ break;
+ }
+ return targetElPos;
+ };
+ Object.defineProperty(PositionService.prototype, "window", {
+ get: function () {
+ return window;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ Object.defineProperty(PositionService.prototype, "document", {
+ get: function () {
+ return window.document;
+ },
+ enumerable: true,
+ configurable: true
+ });
+ PositionService.prototype.getStyle = function (nativeEl, cssProp) {
+ // IE
+ if (nativeEl.currentStyle) {
+ return nativeEl.currentStyle[cssProp];
+ }
+ if (this.window.getComputedStyle) {
+ return this.window.getComputedStyle(nativeEl)[cssProp];
+ }
+ // finally try and get inline style
+ return nativeEl.style[cssProp];
+ };
+ /**
+ * Checks if a given element is statically positioned
+ * @param nativeEl - raw DOM element
+ */
+ PositionService.prototype.isStaticPositioned = function (nativeEl) {
+ return (this.getStyle(nativeEl, 'position') || 'static') === 'static';
+ };
+ /**
+ * returns the closest, non-statically positioned parentOffset of a given
+ * element
+ * @param nativeEl
+ */
+ PositionService.prototype.parentOffsetEl = function (nativeEl) {
+ var offsetParent = nativeEl.offsetParent || this.document;
+ while (offsetParent && offsetParent !== this.document &&
+ this.isStaticPositioned(offsetParent)) {
+ offsetParent = offsetParent.offsetParent;
+ }
+ return offsetParent || this.document;
+ };
+ ;
+ return PositionService;
+ }());
+ exports.PositionService = PositionService;
+ exports.positionService = new PositionService();
+
+
+/***/ },
+/* 72 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+ var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+ if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+ else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+ return c > 3 && r && Object.defineProperty(target, key, r), r;
+ };
+ var __metadata = (this && this.__metadata) || function (k, v) {
+ if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+ };
+ var core_1 = __webpack_require__(1);
+ var progressConfig = {
+ animate: true,
+ max: 100
+ };
+ // todo: progress element conflict with bootstrap.css
+ // todo: need hack: replace host element with div
+ /* tslint:disable */
+ var ProgressDirective = (function () {
+ function ProgressDirective() {
+ this.addClass = true;
+ this.bars = [];
+ }
+ Object.defineProperty(ProgressDirective.prototype, "max", {
+ get: function () {
+ return this._max;
+ },
+ set: function (v) {
+ this._max = v;
+ this.bars.forEach(function (bar) {
+ bar.recalculatePercentage();
+ });
+ },
+ enumerable: true,
+ configurable: true
+ });
+ ProgressDirective.prototype.ngOnInit = function () {
+ this.animate = this.animate !== false;
+ this.max = typeof this.max === 'number' ? this.max : progressConfig.max;
+ };
+ ProgressDirective.prototype.addBar = function (bar) {
+ if (!this.animate) {
+ bar.transition = 'none';
+ }
+ this.bars.push(bar);
+ };
+ ProgressDirective.prototype.removeBar = function (bar) {
+ this.bars.splice(this.bars.indexOf(bar), 1);
+ };
+ __decorate([
+ core_1.Input(),
+ __metadata('design:type', Boolean)
+ ], ProgressDirective.prototype, "animate", void 0);
+ __decorate([
+ core_1.HostBinding('attr.max'),
+ core_1.Input(),
+ __metadata('design:type', Number)
+ ], ProgressDirective.prototype, "max", null);
+ __decorate([
+ core_1.HostBinding('class.progress'),
+ __metadata('design:type', Boolean)
+ ], ProgressDirective.prototype, "addClass", void 0);
+ ProgressDirective = __decorate([
+ core_1.Directive({ selector: 'bs-progress, [progress]' }),
+ __metadata('design:paramtypes', [])
+ ], ProgressDirective);
+ return ProgressDirective;
+ }());
+ exports.ProgressDirective = ProgressDirective;
+
+
+/***/ },
+/* 73 */,
+/* 74 */,
+/* 75 */,
+/* 76 */,
+/* 77 */,
+/* 78 */,
+/* 79 */,
+/* 80 */,
+/* 81 */,
+/* 82 */,
+/* 83 */,
+/* 84 */,
+/* 85 */,
+/* 86 */,
+/* 87 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ function __export(m) {
+ for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+ }
+ __export(__webpack_require__(356));
+ //# sourceMappingURL=index.js.map
+
+/***/ },
+/* 88 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var core_1 = __webpack_require__(1);
+ var core_private_1 = __webpack_require__(13);
+ var lang_1 = __webpack_require__(3);
+ var exceptions_1 = __webpack_require__(8);
+ var collection_1 = __webpack_require__(7);
+ function _isDirectiveMetadata(type) {
+ return type instanceof core_1.DirectiveMetadata;
+ }
+ var DirectiveResolver = (function () {
+ function DirectiveResolver(_reflector) {
+ if (lang_1.isPresent(_reflector)) {
+ this._reflector = _reflector;
+ }
+ else {
+ this._reflector = core_1.reflector;
+ }
+ }
+ /**
+ * Return {@link DirectiveMetadata} for a given `Type`.
+ */
+ DirectiveResolver.prototype.resolve = function (type) {
+ var typeMetadata = this._reflector.annotations(core_1.resolveForwardRef(type));
+ if (lang_1.isPresent(typeMetadata)) {
+ var metadata = typeMetadata.find(_isDirectiveMetadata);
+ if (lang_1.isPresent(metadata)) {
+ var propertyMetadata = this._reflector.propMetadata(type);
+ return this._mergeWithPropertyMetadata(metadata, propertyMetadata, type);
+ }
+ }
+ throw new exceptions_1.BaseException("No Directive annotation found on " + lang_1.stringify(type));
+ };
+ DirectiveResolver.prototype._mergeWithPropertyMetadata = function (dm, propertyMetadata, directiveType) {
+ var inputs = [];
+ var outputs = [];
+ var host = {};
+ var queries = {};
+ collection_1.StringMapWrapper.forEach(propertyMetadata, function (metadata, propName) {
+ metadata.forEach(function (a) {
+ if (a instanceof core_1.InputMetadata) {
+ if (lang_1.isPresent(a.bindingPropertyName)) {
+ inputs.push(propName + ": " + a.bindingPropertyName);
+ }
+ else {
+ inputs.push(propName);
+ }
+ }
+ if (a instanceof core_1.OutputMetadata) {
+ if (lang_1.isPresent(a.bindingPropertyName)) {
+ outputs.push(propName + ": " + a.bindingPropertyName);
+ }
+ else {
+ outputs.push(propName);
+ }
+ }
+ if (a instanceof core_1.HostBindingMetadata) {
+ if (lang_1.isPresent(a.hostPropertyName)) {
+ host[("[" + a.hostPropertyName + "]")] = propName;
+ }
+ else {
+ host[("[" + propName + "]")] = propName;
+ }
+ }
+ if (a instanceof core_1.HostListenerMetadata) {
+ var args = lang_1.isPresent(a.args) ? a.args.join(', ') : '';
+ host[("(" + a.eventName + ")")] = propName + "(" + args + ")";
+ }
+ if (a instanceof core_1.ContentChildrenMetadata) {
+ queries[propName] = a;
+ }
+ if (a instanceof core_1.ViewChildrenMetadata) {
+ queries[propName] = a;
+ }
+ if (a instanceof core_1.ContentChildMetadata) {
+ queries[propName] = a;
+ }
+ if (a instanceof core_1.ViewChildMetadata) {
+ queries[propName] = a;
+ }
+ });
+ });
+ return this._merge(dm, inputs, outputs, host, queries, directiveType);
+ };
+ DirectiveResolver.prototype._merge = function (dm, inputs, outputs, host, queries, directiveType) {
+ var mergedInputs = lang_1.isPresent(dm.inputs) ? collection_1.ListWrapper.concat(dm.inputs, inputs) : inputs;
+ var mergedOutputs;
+ if (lang_1.isPresent(dm.outputs)) {
+ dm.outputs.forEach(function (propName) {
+ if (collection_1.ListWrapper.contains(outputs, propName)) {
+ throw new exceptions_1.BaseException("Output event '" + propName + "' defined multiple times in '" + lang_1.stringify(directiveType) + "'");
+ }
+ });
+ mergedOutputs = collection_1.ListWrapper.concat(dm.outputs, outputs);
+ }
+ else {
+ mergedOutputs = outputs;
+ }
+ var mergedHost = lang_1.isPresent(dm.host) ? collection_1.StringMapWrapper.merge(dm.host, host) : host;
+ var mergedQueries = lang_1.isPresent(dm.queries) ? collection_1.StringMapWrapper.merge(dm.queries, queries) : queries;
+ if (dm instanceof core_1.ComponentMetadata) {
+ return new core_1.ComponentMetadata({
+ selector: dm.selector,
+ inputs: mergedInputs,
+ outputs: mergedOutputs,
+ host: mergedHost,
+ exportAs: dm.exportAs,
+ moduleId: dm.moduleId,
+ queries: mergedQueries,
+ changeDetection: dm.changeDetection,
+ providers: dm.providers,
+ viewProviders: dm.viewProviders
+ });
+ }
+ else {
+ return new core_1.DirectiveMetadata({
+ selector: dm.selector,
+ inputs: mergedInputs,
+ outputs: mergedOutputs,
+ host: mergedHost,
+ exportAs: dm.exportAs,
+ queries: mergedQueries,
+ providers: dm.providers
+ });
+ }
+ };
+ DirectiveResolver.decorators = [
+ { type: core_1.Injectable },
+ ];
+ DirectiveResolver.ctorParameters = [
+ { type: core_private_1.ReflectorReader, },
+ ];
+ return DirectiveResolver;
+ }());
+ exports.DirectiveResolver = DirectiveResolver;
+ exports.CODEGEN_DIRECTIVE_RESOLVER = new DirectiveResolver(core_1.reflector);
+ //# sourceMappingURL=directive_resolver.js.map
+
+/***/ },
+/* 89 */
+[459, 3, 361],
+/* 90 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var lang_1 = __webpack_require__(3);
+ var HtmlTextAst = (function () {
+ function HtmlTextAst(value, sourceSpan) {
+ this.value = value;
+ this.sourceSpan = sourceSpan;
+ }
+ HtmlTextAst.prototype.visit = function (visitor, context) { return visitor.visitText(this, context); };
+ return HtmlTextAst;
+ }());
+ exports.HtmlTextAst = HtmlTextAst;
+ var HtmlExpansionAst = (function () {
+ function HtmlExpansionAst(switchValue, type, cases, sourceSpan, switchValueSourceSpan) {
+ this.switchValue = switchValue;
+ this.type = type;
+ this.cases = cases;
+ this.sourceSpan = sourceSpan;
+ this.switchValueSourceSpan = switchValueSourceSpan;
+ }
+ HtmlExpansionAst.prototype.visit = function (visitor, context) {
+ return visitor.visitExpansion(this, context);
+ };
+ return HtmlExpansionAst;
+ }());
+ exports.HtmlExpansionAst = HtmlExpansionAst;
+ var HtmlExpansionCaseAst = (function () {
+ function HtmlExpansionCaseAst(value, expression, sourceSpan, valueSourceSpan, expSourceSpan) {
+ this.value = value;
+ this.expression = expression;
+ this.sourceSpan = sourceSpan;
+ this.valueSourceSpan = valueSourceSpan;
+ this.expSourceSpan = expSourceSpan;
+ }
+ HtmlExpansionCaseAst.prototype.visit = function (visitor, context) {
+ return visitor.visitExpansionCase(this, context);
+ };
+ return HtmlExpansionCaseAst;
+ }());
+ exports.HtmlExpansionCaseAst = HtmlExpansionCaseAst;
+ var HtmlAttrAst = (function () {
+ function HtmlAttrAst(name, value, sourceSpan) {
+ this.name = name;
+ this.value = value;
+ this.sourceSpan = sourceSpan;
+ }
+ HtmlAttrAst.prototype.visit = function (visitor, context) { return visitor.visitAttr(this, context); };
+ return HtmlAttrAst;
+ }());
+ exports.HtmlAttrAst = HtmlAttrAst;
+ var HtmlElementAst = (function () {
+ function HtmlElementAst(name, attrs, children, sourceSpan, startSourceSpan, endSourceSpan) {
+ this.name = name;
+ this.attrs = attrs;
+ this.children = children;
+ this.sourceSpan = sourceSpan;
+ this.startSourceSpan = startSourceSpan;
+ this.endSourceSpan = endSourceSpan;
+ }
+ HtmlElementAst.prototype.visit = function (visitor, context) { return visitor.visitElement(this, context); };
+ return HtmlElementAst;
+ }());
+ exports.HtmlElementAst = HtmlElementAst;
+ var HtmlCommentAst = (function () {
+ function HtmlCommentAst(value, sourceSpan) {
+ this.value = value;
+ this.sourceSpan = sourceSpan;
+ }
+ HtmlCommentAst.prototype.visit = function (visitor, context) { return visitor.visitComment(this, context); };
+ return HtmlCommentAst;
+ }());
+ exports.HtmlCommentAst = HtmlCommentAst;
+ function htmlVisitAll(visitor, asts, context) {
+ if (context === void 0) { context = null; }
+ var result = [];
+ asts.forEach(function (ast) {
+ var astResult = ast.visit(visitor, context);
+ if (lang_1.isPresent(astResult)) {
+ result.push(astResult);
+ }
+ });
+ return result;
+ }
+ exports.htmlVisitAll = htmlVisitAll;
+ //# sourceMappingURL=html_ast.js.map
+
+/***/ },
+/* 91 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var __extends = (this && this.__extends) || function (d, b) {
+ for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ var core_1 = __webpack_require__(1);
+ var lang_1 = __webpack_require__(3);
+ var collection_1 = __webpack_require__(7);
+ var html_ast_1 = __webpack_require__(90);
+ var html_lexer_1 = __webpack_require__(362);
+ var parse_util_1 = __webpack_require__(56);
+ var html_tags_1 = __webpack_require__(54);
+ var HtmlTreeError = (function (_super) {
+ __extends(HtmlTreeError, _super);
+ function HtmlTreeError(elementName, span, msg) {
+ _super.call(this, span, msg);
+ this.elementName = elementName;
+ }
+ HtmlTreeError.create = function (elementName, span, msg) {
+ return new HtmlTreeError(elementName, span, msg);
+ };
+ return HtmlTreeError;
+ }(parse_util_1.ParseError));
+ exports.HtmlTreeError = HtmlTreeError;
+ var HtmlParseTreeResult = (function () {
+ function HtmlParseTreeResult(rootNodes, errors) {
+ this.rootNodes = rootNodes;
+ this.errors = errors;
+ }
+ return HtmlParseTreeResult;
+ }());
+ exports.HtmlParseTreeResult = HtmlParseTreeResult;
+ var HtmlParser = (function () {
+ function HtmlParser() {
+ }
+ HtmlParser.prototype.parse = function (sourceContent, sourceUrl, parseExpansionForms) {
+ if (parseExpansionForms === void 0) { parseExpansionForms = false; }
+ var tokensAndErrors = html_lexer_1.tokenizeHtml(sourceContent, sourceUrl, parseExpansionForms);
+ var treeAndErrors = new TreeBuilder(tokensAndErrors.tokens).build();
+ return new HtmlParseTreeResult(treeAndErrors.rootNodes, tokensAndErrors.errors
+ .concat(treeAndErrors.errors));
+ };
+ HtmlParser.decorators = [
+ { type: core_1.Injectable },
+ ];
+ return HtmlParser;
+ }());
+ exports.HtmlParser = HtmlParser;
+ var TreeBuilder = (function () {
+ function TreeBuilder(tokens) {
+ this.tokens = tokens;
+ this.index = -1;
+ this.rootNodes = [];
+ this.errors = [];
+ this.elementStack = [];
+ this._advance();
+ }
+ TreeBuilder.prototype.build = function () {
+ while (this.peek.type !== html_lexer_1.HtmlTokenType.EOF) {
+ if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_OPEN_START) {
+ this._consumeStartTag(this._advance());
+ }
+ else if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_CLOSE) {
+ this._consumeEndTag(this._advance());
+ }
+ else if (this.peek.type === html_lexer_1.HtmlTokenType.CDATA_START) {
+ this._closeVoidElement();
+ this._consumeCdata(this._advance());
+ }
+ else if (this.peek.type === html_lexer_1.HtmlTokenType.COMMENT_START) {
+ this._closeVoidElement();
+ this._consumeComment(this._advance());
+ }
+ else if (this.peek.type === html_lexer_1.HtmlTokenType.TEXT ||
+ this.peek.type === html_lexer_1.HtmlTokenType.RAW_TEXT ||
+ this.peek.type === html_lexer_1.HtmlTokenType.ESCAPABLE_RAW_TEXT) {
+ this._closeVoidElement();
+ this._consumeText(this._advance());
+ }
+ else if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_FORM_START) {
+ this._consumeExpansion(this._advance());
+ }
+ else {
+ // Skip all other tokens...
+ this._advance();
+ }
+ }
+ return new HtmlParseTreeResult(this.rootNodes, this.errors);
+ };
+ TreeBuilder.prototype._advance = function () {
+ var prev = this.peek;
+ if (this.index < this.tokens.length - 1) {
+ // Note: there is always an EOF token at the end
+ this.index++;
+ }
+ this.peek = this.tokens[this.index];
+ return prev;
+ };
+ TreeBuilder.prototype._advanceIf = function (type) {
+ if (this.peek.type === type) {
+ return this._advance();
+ }
+ return null;
+ };
+ TreeBuilder.prototype._consumeCdata = function (startToken) {
+ this._consumeText(this._advance());
+ this._advanceIf(html_lexer_1.HtmlTokenType.CDATA_END);
+ };
+ TreeBuilder.prototype._consumeComment = function (token) {
+ var text = this._advanceIf(html_lexer_1.HtmlTokenType.RAW_TEXT);
+ this._advanceIf(html_lexer_1.HtmlTokenType.COMMENT_END);
+ var value = lang_1.isPresent(text) ? text.parts[0].trim() : null;
+ this._addToParent(new html_ast_1.HtmlCommentAst(value, token.sourceSpan));
+ };
+ TreeBuilder.prototype._consumeExpansion = function (token) {
+ var switchValue = this._advance();
+ var type = this._advance();
+ var cases = [];
+ // read =
+ while (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_CASE_VALUE) {
+ var expCase = this._parseExpansionCase();
+ if (lang_1.isBlank(expCase))
+ return; // error
+ cases.push(expCase);
+ }
+ // read the final }
+ if (this.peek.type !== html_lexer_1.HtmlTokenType.EXPANSION_FORM_END) {
+ this.errors.push(HtmlTreeError.create(null, this.peek.sourceSpan, "Invalid expansion form. Missing '}'."));
+ return;
+ }
+ this._advance();
+ var mainSourceSpan = new parse_util_1.ParseSourceSpan(token.sourceSpan.start, this.peek.sourceSpan.end);
+ this._addToParent(new html_ast_1.HtmlExpansionAst(switchValue.parts[0], type.parts[0], cases, mainSourceSpan, switchValue.sourceSpan));
+ };
+ TreeBuilder.prototype._parseExpansionCase = function () {
+ var value = this._advance();
+ // read {
+ if (this.peek.type !== html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START) {
+ this.errors.push(HtmlTreeError.create(null, this.peek.sourceSpan, "Invalid expansion form. Missing '{'.,"));
+ return null;
+ }
+ // read until }
+ var start = this._advance();
+ var exp = this._collectExpansionExpTokens(start);
+ if (lang_1.isBlank(exp))
+ return null;
+ var end = this._advance();
+ exp.push(new html_lexer_1.HtmlToken(html_lexer_1.HtmlTokenType.EOF, [], end.sourceSpan));
+ // parse everything in between { and }
+ var parsedExp = new TreeBuilder(exp).build();
+ if (parsedExp.errors.length > 0) {
+ this.errors = this.errors.concat(parsedExp.errors);
+ return null;
+ }
+ var sourceSpan = new parse_util_1.ParseSourceSpan(value.sourceSpan.start, end.sourceSpan.end);
+ var expSourceSpan = new parse_util_1.ParseSourceSpan(start.sourceSpan.start, end.sourceSpan.end);
+ return new html_ast_1.HtmlExpansionCaseAst(value.parts[0], parsedExp.rootNodes, sourceSpan, value.sourceSpan, expSourceSpan);
+ };
+ TreeBuilder.prototype._collectExpansionExpTokens = function (start) {
+ var exp = [];
+ var expansionFormStack = [html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START];
+ while (true) {
+ if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_FORM_START ||
+ this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START) {
+ expansionFormStack.push(this.peek.type);
+ }
+ if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_END) {
+ if (lastOnStack(expansionFormStack, html_lexer_1.HtmlTokenType.EXPANSION_CASE_EXP_START)) {
+ expansionFormStack.pop();
+ if (expansionFormStack.length == 0)
+ return exp;
+ }
+ else {
+ this.errors.push(HtmlTreeError.create(null, start.sourceSpan, "Invalid expansion form. Missing '}'."));
+ return null;
+ }
+ }
+ if (this.peek.type === html_lexer_1.HtmlTokenType.EXPANSION_FORM_END) {
+ if (lastOnStack(expansionFormStack, html_lexer_1.HtmlTokenType.EXPANSION_FORM_START)) {
+ expansionFormStack.pop();
+ }
+ else {
+ this.errors.push(HtmlTreeError.create(null, start.sourceSpan, "Invalid expansion form. Missing '}'."));
+ return null;
+ }
+ }
+ if (this.peek.type === html_lexer_1.HtmlTokenType.EOF) {
+ this.errors.push(HtmlTreeError.create(null, start.sourceSpan, "Invalid expansion form. Missing '}'."));
+ return null;
+ }
+ exp.push(this._advance());
+ }
+ };
+ TreeBuilder.prototype._consumeText = function (token) {
+ var text = token.parts[0];
+ if (text.length > 0 && text[0] == '\n') {
+ var parent_1 = this._getParentElement();
+ if (lang_1.isPresent(parent_1) && parent_1.children.length == 0 &&
+ html_tags_1.getHtmlTagDefinition(parent_1.name).ignoreFirstLf) {
+ text = text.substring(1);
+ }
+ }
+ if (text.length > 0) {
+ this._addToParent(new html_ast_1.HtmlTextAst(text, token.sourceSpan));
+ }
+ };
+ TreeBuilder.prototype._closeVoidElement = function () {
+ if (this.elementStack.length > 0) {
+ var el = collection_1.ListWrapper.last(this.elementStack);
+ if (html_tags_1.getHtmlTagDefinition(el.name).isVoid) {
+ this.elementStack.pop();
+ }
+ }
+ };
+ TreeBuilder.prototype._consumeStartTag = function (startTagToken) {
+ var prefix = startTagToken.parts[0];
+ var name = startTagToken.parts[1];
+ var attrs = [];
+ while (this.peek.type === html_lexer_1.HtmlTokenType.ATTR_NAME) {
+ attrs.push(this._consumeAttr(this._advance()));
+ }
+ var fullName = getElementFullName(prefix, name, this._getParentElement());
+ var selfClosing = false;
+ // Note: There could have been a tokenizer error
+ // so that we don't get a token for the end tag...
+ if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_OPEN_END_VOID) {
+ this._advance();
+ selfClosing = true;
+ if (html_tags_1.getNsPrefix(fullName) == null && !html_tags_1.getHtmlTagDefinition(fullName).isVoid) {
+ this.errors.push(HtmlTreeError.create(fullName, startTagToken.sourceSpan, "Only void and foreign elements can be self closed \"" + startTagToken.parts[1] + "\""));
+ }
+ }
+ else if (this.peek.type === html_lexer_1.HtmlTokenType.TAG_OPEN_END) {
+ this._advance();
+ selfClosing = false;
+ }
+ var end = this.peek.sourceSpan.start;
+ var span = new parse_util_1.ParseSourceSpan(startTagToken.sourceSpan.start, end);
+ var el = new html_ast_1.HtmlElementAst(fullName, attrs, [], span, span, null);
+ this._pushElement(el);
+ if (selfClosing) {
+ this._popElement(fullName);
+ el.endSourceSpan = span;
+ }
+ };
+ TreeBuilder.prototype._pushElement = function (el) {
+ if (this.elementStack.length > 0) {
+ var parentEl = collection_1.ListWrapper.last(this.elementStack);
+ if (html_tags_1.getHtmlTagDefinition(parentEl.name).isClosedByChild(el.name)) {
+ this.elementStack.pop();
+ }
+ }
+ var tagDef = html_tags_1.getHtmlTagDefinition(el.name);
+ var parentEl = this._getParentElement();
+ if (tagDef.requireExtraParent(lang_1.isPresent(parentEl) ? parentEl.name : null)) {
+ var newParent = new html_ast_1.HtmlElementAst(tagDef.parentToAdd, [], [el], el.sourceSpan, el.startSourceSpan, el.endSourceSpan);
+ this._addToParent(newParent);
+ this.elementStack.push(newParent);
+ this.elementStack.push(el);
+ }
+ else {
+ this._addToParent(el);
+ this.elementStack.push(el);
+ }
+ };
+ TreeBuilder.prototype._consumeEndTag = function (endTagToken) {
+ var fullName = getElementFullName(endTagToken.parts[0], endTagToken.parts[1], this._getParentElement());
+ this._getParentElement().endSourceSpan = endTagToken.sourceSpan;
+ if (html_tags_1.getHtmlTagDefinition(fullName).isVoid) {
+ this.errors.push(HtmlTreeError.create(fullName, endTagToken.sourceSpan, "Void elements do not have end tags \"" + endTagToken.parts[1] + "\""));
+ }
+ else if (!this._popElement(fullName)) {
+ this.errors.push(HtmlTreeError.create(fullName, endTagToken.sourceSpan, "Unexpected closing tag \"" + endTagToken.parts[1] + "\""));
+ }
+ };
+ TreeBuilder.prototype._popElement = function (fullName) {
+ for (var stackIndex = this.elementStack.length - 1; stackIndex >= 0; stackIndex--) {
+ var el = this.elementStack[stackIndex];
+ if (el.name == fullName) {
+ collection_1.ListWrapper.splice(this.elementStack, stackIndex, this.elementStack.length - stackIndex);
+ return true;
+ }
+ if (!html_tags_1.getHtmlTagDefinition(el.name).closedByParent) {
+ return false;
+ }
+ }
+ return false;
+ };
+ TreeBuilder.prototype._consumeAttr = function (attrName) {
+ var fullName = html_tags_1.mergeNsAndName(attrName.parts[0], attrName.parts[1]);
+ var end = attrName.sourceSpan.end;
+ var value = '';
+ if (this.peek.type === html_lexer_1.HtmlTokenType.ATTR_VALUE) {
+ var valueToken = this._advance();
+ value = valueToken.parts[0];
+ end = valueToken.sourceSpan.end;
+ }
+ return new html_ast_1.HtmlAttrAst(fullName, value, new parse_util_1.ParseSourceSpan(attrName.sourceSpan.start, end));
+ };
+ TreeBuilder.prototype._getParentElement = function () {
+ return this.elementStack.length > 0 ? collection_1.ListWrapper.last(this.elementStack) : null;
+ };
+ TreeBuilder.prototype._addToParent = function (node) {
+ var parent = this._getParentElement();
+ if (lang_1.isPresent(parent)) {
+ parent.children.push(node);
+ }
+ else {
+ this.rootNodes.push(node);
+ }
+ };
+ return TreeBuilder;
+ }());
+ function getElementFullName(prefix, localName, parentElement) {
+ if (lang_1.isBlank(prefix)) {
+ prefix = html_tags_1.getHtmlTagDefinition(localName).implicitNamespacePrefix;
+ if (lang_1.isBlank(prefix) && lang_1.isPresent(parentElement)) {
+ prefix = html_tags_1.getNsPrefix(parentElement.name);
+ }
+ }
+ return html_tags_1.mergeNsAndName(prefix, localName);
+ }
+ function lastOnStack(stack, element) {
+ return stack.length > 0 && stack[stack.length - 1] === element;
+ }
+ //# sourceMappingURL=html_parser.js.map
+
+/***/ },
+/* 92 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var core_1 = __webpack_require__(1);
+ var core_private_1 = __webpack_require__(13);
+ var lang_1 = __webpack_require__(3);
+ var exceptions_1 = __webpack_require__(8);
+ function _isPipeMetadata(type) {
+ return type instanceof core_1.PipeMetadata;
+ }
+ var PipeResolver = (function () {
+ function PipeResolver(_reflector) {
+ if (lang_1.isPresent(_reflector)) {
+ this._reflector = _reflector;
+ }
+ else {
+ this._reflector = core_1.reflector;
+ }
+ }
+ /**
+ * Return {@link PipeMetadata} for a given `Type`.
+ */
+ PipeResolver.prototype.resolve = function (type) {
+ var metas = this._reflector.annotations(core_1.resolveForwardRef(type));
+ if (lang_1.isPresent(metas)) {
+ var annotation = metas.find(_isPipeMetadata);
+ if (lang_1.isPresent(annotation)) {
+ return annotation;
+ }
+ }
+ throw new exceptions_1.BaseException("No Pipe decorator found on " + lang_1.stringify(type));
+ };
+ PipeResolver.decorators = [
+ { type: core_1.Injectable },
+ ];
+ PipeResolver.ctorParameters = [
+ { type: core_private_1.ReflectorReader, },
+ ];
+ return PipeResolver;
+ }());
+ exports.PipeResolver = PipeResolver;
+ exports.CODEGEN_PIPE_RESOLVER = new PipeResolver(core_1.reflector);
+ //# sourceMappingURL=pipe_resolver.js.map
+
+/***/ },
+/* 93 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var collection_1 = __webpack_require__(7);
+ var lang_1 = __webpack_require__(3);
+ var exceptions_1 = __webpack_require__(8);
+ var _EMPTY_ATTR_VALUE = '';
+ // TODO: Can't use `const` here as
+ // in Dart this is not transpiled into `final` yet...
+ var _SELECTOR_REGEXP = lang_1.RegExpWrapper.create('(\\:not\\()|' +
+ '([-\\w]+)|' +
+ '(?:\\.([-\\w]+))|' +
+ '(?:\\[([-\\w*]+)(?:=([^\\]]*))?\\])|' +
+ '(\\))|' +
+ '(\\s*,\\s*)'); // ","
+ /**
+ * A css selector contains an element name,
+ * css classes and attribute/value pairs with the purpose
+ * of selecting subsets out of them.
+ */
+ var CssSelector = (function () {
+ function CssSelector() {
+ this.element = null;
+ this.classNames = [];
+ this.attrs = [];
+ this.notSelectors = [];
+ }
+ CssSelector.parse = function (selector) {
+ var results = [];
+ var _addResult = function (res, cssSel) {
+ if (cssSel.notSelectors.length > 0 && lang_1.isBlank(cssSel.element) &&
+ collection_1.ListWrapper.isEmpty(cssSel.classNames) && collection_1.ListWrapper.isEmpty(cssSel.attrs)) {
+ cssSel.element = "*";
+ }
+ res.push(cssSel);
+ };
+ var cssSelector = new CssSelector();
+ var matcher = lang_1.RegExpWrapper.matcher(_SELECTOR_REGEXP, selector);
+ var match;
+ var current = cssSelector;
+ var inNot = false;
+ while (lang_1.isPresent(match = lang_1.RegExpMatcherWrapper.next(matcher))) {
+ if (lang_1.isPresent(match[1])) {
+ if (inNot) {
+ throw new exceptions_1.BaseException('Nesting :not is not allowed in a selector');
+ }
+ inNot = true;
+ current = new CssSelector();
+ cssSelector.notSelectors.push(current);
+ }
+ if (lang_1.isPresent(match[2])) {
+ current.setElement(match[2]);
+ }
+ if (lang_1.isPresent(match[3])) {
+ current.addClassName(match[3]);
+ }
+ if (lang_1.isPresent(match[4])) {
+ current.addAttribute(match[4], match[5]);
+ }
+ if (lang_1.isPresent(match[6])) {
+ inNot = false;
+ current = cssSelector;
+ }
+ if (lang_1.isPresent(match[7])) {
+ if (inNot) {
+ throw new exceptions_1.BaseException('Multiple selectors in :not are not supported');
+ }
+ _addResult(results, cssSelector);
+ cssSelector = current = new CssSelector();
+ }
+ }
+ _addResult(results, cssSelector);
+ return results;
+ };
+ CssSelector.prototype.isElementSelector = function () {
+ return lang_1.isPresent(this.element) && collection_1.ListWrapper.isEmpty(this.classNames) &&
+ collection_1.ListWrapper.isEmpty(this.attrs) && this.notSelectors.length === 0;
+ };
+ CssSelector.prototype.setElement = function (element) {
+ if (element === void 0) { element = null; }
+ this.element = element;
+ };
+ /** Gets a template string for an element that matches the selector. */
+ CssSelector.prototype.getMatchingElementTemplate = function () {
+ var tagName = lang_1.isPresent(this.element) ? this.element : 'div';
+ var classAttr = this.classNames.length > 0 ? " class=\"" + this.classNames.join(' ') + "\"" : '';
+ var attrs = '';
+ for (var i = 0; i < this.attrs.length; i += 2) {
+ var attrName = this.attrs[i];
+ var attrValue = this.attrs[i + 1] !== '' ? "=\"" + this.attrs[i + 1] + "\"" : '';
+ attrs += " " + attrName + attrValue;
+ }
+ return "<" + tagName + classAttr + attrs + ">";
+ };
+ CssSelector.prototype.addAttribute = function (name, value) {
+ if (value === void 0) { value = _EMPTY_ATTR_VALUE; }
+ this.attrs.push(name);
+ if (lang_1.isPresent(value)) {
+ value = value.toLowerCase();
+ }
+ else {
+ value = _EMPTY_ATTR_VALUE;
+ }
+ this.attrs.push(value);
+ };
+ CssSelector.prototype.addClassName = function (name) { this.classNames.push(name.toLowerCase()); };
+ CssSelector.prototype.toString = function () {
+ var res = '';
+ if (lang_1.isPresent(this.element)) {
+ res += this.element;
+ }
+ if (lang_1.isPresent(this.classNames)) {
+ for (var i = 0; i < this.classNames.length; i++) {
+ res += '.' + this.classNames[i];
+ }
+ }
+ if (lang_1.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 += ']';
+ }
+ }
+ this.notSelectors.forEach(function (notSelector) { return res += ":not(" + notSelector + ")"; });
+ return res;
+ };
+ return CssSelector;
+ }());
+ exports.CssSelector = CssSelector;
+ /**
+ * Reads a list of CssSelectors and allows to calculate which ones
+ * are contained in a given CssSelector.
+ */
+ var SelectorMatcher = (function () {
+ function SelectorMatcher() {
+ this._elementMap = new collection_1.Map();
+ this._elementPartialMap = new collection_1.Map();
+ this._classMap = new collection_1.Map();
+ this._classPartialMap = new collection_1.Map();
+ this._attrValueMap = new collection_1.Map();
+ this._attrValuePartialMap = new collection_1.Map();
+ this._listContexts = [];
+ }
+ SelectorMatcher.createNotMatcher = function (notSelectors) {
+ var notMatcher = new SelectorMatcher();
+ notMatcher.addSelectables(notSelectors, null);
+ return notMatcher;
+ };
+ SelectorMatcher.prototype.addSelectables = function (cssSelectors, callbackCtxt) {
+ var listContext = null;
+ if (cssSelectors.length > 1) {
+ listContext = new SelectorListContext(cssSelectors);
+ this._listContexts.push(listContext);
+ }
+ for (var i = 0; i < cssSelectors.length; i++) {
+ this._addSelectable(cssSelectors[i], callbackCtxt, listContext);
+ }
+ };
+ /**
+ * Add an object that can be found later on by calling `match`.
+ * @param cssSelector A css selector
+ * @param callbackCtxt An opaque object that will be given to the callback of the `match` function
+ */
+ SelectorMatcher.prototype._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 (lang_1.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 (lang_1.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 (lang_1.isPresent(attrs)) {
+ for (var index = 0; index < attrs.length;) {
+ var isTerminal = index === attrs.length - 2;
+ var attrName = attrs[index++];
+ var attrValue = attrs[index++];
+ if (isTerminal) {
+ var terminalMap = matcher._attrValueMap;
+ var terminalValuesMap = terminalMap.get(attrName);
+ if (lang_1.isBlank(terminalValuesMap)) {
+ terminalValuesMap = new collection_1.Map();
+ terminalMap.set(attrName, terminalValuesMap);
+ }
+ this._addTerminal(terminalValuesMap, attrValue, selectable);
+ }
+ else {
+ var parttialMap = matcher._attrValuePartialMap;
+ var partialValuesMap = parttialMap.get(attrName);
+ if (lang_1.isBlank(partialValuesMap)) {
+ partialValuesMap = new collection_1.Map();
+ parttialMap.set(attrName, partialValuesMap);
+ }
+ matcher = this._addPartial(partialValuesMap, attrValue);
+ }
+ }
+ }
+ };
+ SelectorMatcher.prototype._addTerminal = function (map, name, selectable) {
+ var terminalList = map.get(name);
+ if (lang_1.isBlank(terminalList)) {
+ terminalList = [];
+ map.set(name, terminalList);
+ }
+ terminalList.push(selectable);
+ };
+ SelectorMatcher.prototype._addPartial = function (map, name) {
+ var matcher = map.get(name);
+ if (lang_1.isBlank(matcher)) {
+ matcher = new SelectorMatcher();
+ map.set(name, matcher);
+ }
+ return matcher;
+ };
+ /**
+ * Find the objects that have been added via `addSelectable`
+ * whose css selector is contained in the given css selector.
+ * @param cssSelector A css selector
+ * @param matchedCallback This callback will be called with the object handed into `addSelectable`
+ * @return boolean true if a match was found
+ */
+ SelectorMatcher.prototype.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 (lang_1.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 (lang_1.isPresent(attrs)) {
+ for (var index = 0; index < attrs.length;) {
+ var attrName = attrs[index++];
+ var attrValue = attrs[index++];
+ var terminalValuesMap = this._attrValueMap.get(attrName);
+ if (!lang_1.StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) {
+ result = this._matchTerminal(terminalValuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) ||
+ result;
+ }
+ result = this._matchTerminal(terminalValuesMap, attrValue, cssSelector, matchedCallback) ||
+ result;
+ var partialValuesMap = this._attrValuePartialMap.get(attrName);
+ if (!lang_1.StringWrapper.equals(attrValue, _EMPTY_ATTR_VALUE)) {
+ result = this._matchPartial(partialValuesMap, _EMPTY_ATTR_VALUE, cssSelector, matchedCallback) ||
+ result;
+ }
+ result =
+ this._matchPartial(partialValuesMap, attrValue, cssSelector, matchedCallback) || result;
+ }
+ }
+ return result;
+ };
+ /** @internal */
+ SelectorMatcher.prototype._matchTerminal = function (map, name, cssSelector, matchedCallback) {
+ if (lang_1.isBlank(map) || lang_1.isBlank(name)) {
+ return false;
+ }
+ var selectables = map.get(name);
+ var starSelectables = map.get("*");
+ if (lang_1.isPresent(starSelectables)) {
+ selectables = selectables.concat(starSelectables);
+ }
+ if (lang_1.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;
+ };
+ /** @internal */
+ SelectorMatcher.prototype._matchPartial = function (map, name, cssSelector, matchedCallback /*: (c: CssSelector, a: any) => void*/) {
+ if (lang_1.isBlank(map) || lang_1.isBlank(name)) {
+ return false;
+ }
+ var nestedSelector = map.get(name);
+ if (lang_1.isBlank(nestedSelector)) {
+ return false;
+ }
+ // TODO(perf): get rid of recursion and measure again
+ // TODO(perf): don't pass the whole selector into the recursion,
+ // but only the not processed parts
+ return nestedSelector.match(cssSelector, matchedCallback);
+ };
+ return SelectorMatcher;
+ }());
+ exports.SelectorMatcher = SelectorMatcher;
+ var SelectorListContext = (function () {
+ function SelectorListContext(selectors) {
+ this.selectors = selectors;
+ this.alreadyMatched = false;
+ }
+ return SelectorListContext;
+ }());
+ exports.SelectorListContext = SelectorListContext;
+ // Store context to pass back selector and context when a selector is matched
+ var SelectorContext = (function () {
+ function SelectorContext(selector, cbContext, listContext) {
+ this.selector = selector;
+ this.cbContext = cbContext;
+ this.listContext = listContext;
+ this.notSelectors = selector.notSelectors;
+ }
+ SelectorContext.prototype.finalize = function (cssSelector, callback) {
+ var result = true;
+ if (this.notSelectors.length > 0 &&
+ (lang_1.isBlank(this.listContext) || !this.listContext.alreadyMatched)) {
+ var notMatcher = SelectorMatcher.createNotMatcher(this.notSelectors);
+ result = !notMatcher.match(cssSelector, null);
+ }
+ if (result && lang_1.isPresent(callback) &&
+ (lang_1.isBlank(this.listContext) || !this.listContext.alreadyMatched)) {
+ if (lang_1.isPresent(this.listContext)) {
+ this.listContext.alreadyMatched = true;
+ }
+ callback(this.selector, this.cbContext);
+ }
+ return result;
+ };
+ return SelectorContext;
+ }());
+ exports.SelectorContext = SelectorContext;
+ //# sourceMappingURL=selector.js.map
+
+/***/ },
+/* 94 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ // Some of the code comes from WebComponents.JS
+ // https://github.com/webcomponents/webcomponentsjs/blob/master/src/HTMLImports/path.js
+ var lang_1 = __webpack_require__(3);
+ var StyleWithImports = (function () {
+ function StyleWithImports(style, styleUrls) {
+ this.style = style;
+ this.styleUrls = styleUrls;
+ }
+ return StyleWithImports;
+ }());
+ exports.StyleWithImports = StyleWithImports;
+ function isStyleUrlResolvable(url) {
+ if (lang_1.isBlank(url) || url.length === 0 || url[0] == '/')
+ return false;
+ var schemeMatch = lang_1.RegExpWrapper.firstMatch(_urlWithSchemaRe, url);
+ return lang_1.isBlank(schemeMatch) || schemeMatch[1] == 'package' || schemeMatch[1] == 'asset';
+ }
+ exports.isStyleUrlResolvable = isStyleUrlResolvable;
+ /**
+ * Rewrites stylesheets by resolving and removing the @import urls that
+ * are either relative or don't have a `package:` scheme
+ */
+ function extractStyleUrls(resolver, baseUrl, cssText) {
+ var foundUrls = [];
+ var modifiedCssText = lang_1.StringWrapper.replaceAllMapped(cssText, _cssImportRe, function (m) {
+ var url = lang_1.isPresent(m[1]) ? m[1] : m[2];
+ if (!isStyleUrlResolvable(url)) {
+ // Do not attempt to resolve non-package absolute URLs with URI scheme
+ return m[0];
+ }
+ foundUrls.push(resolver.resolve(baseUrl, url));
+ return '';
+ });
+ return new StyleWithImports(modifiedCssText, foundUrls);
+ }
+ exports.extractStyleUrls = extractStyleUrls;
+ var _cssImportRe = /@import\s+(?:url\()?\s*(?:(?:['"]([^'"]*))|([^;\)\s]*))[^;]*;?/g;
+ // TODO: can't use /^[^:/?#.]+:/g due to clang-format bug:
+ // https://github.com/angular/angular/issues/4596
+ var _urlWithSchemaRe = /^([a-zA-Z\-\+\.]+):/g;
+ //# sourceMappingURL=style_url_resolver.js.map
+
+/***/ },
+/* 95 */
+/***/ function(module, exports, __webpack_require__) {
+
+ "use strict";
+ var __extends = (this && this.__extends) || function (d, b) {
+ for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
+ function __() { this.constructor = d; }
+ d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+ };
+ var core_1 = __webpack_require__(1);
+ var core_private_1 = __webpack_require__(13);
+ var collection_1 = __webpack_require__(7);
+ var lang_1 = __webpack_require__(3);
+ var exceptions_1 = __webpack_require__(8);
+ var ast_1 = __webpack_require__(165);
+ var parser_1 = __webpack_require__(167);
+ var html_parser_1 = __webpack_require__(91);
+ var html_tags_1 = __webpack_require__(54);
+ var parse_util_1 = __webpack_require__(56);
+ var template_ast_1 = __webpack_require__(24);
+ var selector_1 = __webpack_require__(93);
+ var element_schema_registry_1 = __webpack_require__(57);
+ var template_preparser_1 = __webpack_require__(173);
+ var style_url_resolver_1 = __webpack_require__(94);
+ var html_ast_1 = __webpack_require__(90);
+ var util_1 = __webpack_require__(25);
+ var identifiers_1 = __webpack_require__(17);
+ var provider_parser_1 = __webpack_require__(371);
+ // Group 1 = "bind-"
+ // Group 2 = "var-"
+ // Group 3 = "let-"
+ // Group 4 = "ref-/#"
+ // Group 5 = "on-"
+ // Group 6 = "bindon-"
+ // Group 7 = the identifier after "bind-", "var-/#", or "on-"
+ // Group 8 = identifier inside [()]
+ // Group 9 = identifier inside []
+ // Group 10 = identifier inside ()
+ var BIND_NAME_REGEXP = /^(?:(?:(?:(bind-)|(var-)|(let-)|(ref-|#)|(on-)|(bindon-))(.+))|\[\(([^\)]+)\)\]|\[([^\]]+)\]|\(([^\)]+)\))$/g;
+ var TEMPLATE_ELEMENT = 'template';
+ var TEMPLATE_ATTR = 'template';
+ var TEMPLATE_ATTR_PREFIX = '*';
+ var CLASS_ATTR = 'class';
+ var PROPERTY_PARTS_SEPARATOR = '.';
+ var ATTRIBUTE_PREFIX = 'attr';
+ var CLASS_PREFIX = 'class';
+ var STYLE_PREFIX = 'style';
+ var TEXT_CSS_SELECTOR = selector_1.CssSelector.parse('*')[0];
+ /**
+ * Provides an array of {@link TemplateAstVisitor}s which will be used to transform
+ * parsed templates before compilation is invoked, allowing custom expression syntax
+ * and other advanced transformations.
+ *
+ * This is currently an internal-only feature and not meant for general use.
+ */
+ exports.TEMPLATE_TRANSFORMS = new core_1.OpaqueToken('TemplateTransforms');
+ var TemplateParseError = (function (_super) {
+ __extends(TemplateParseError, _super);
+ function TemplateParseError(message, span, level) {
+ _super.call(this, span, message, level);
+ }
+ return TemplateParseError;
+ }(parse_util_1.ParseError));
+ exports.TemplateParseError = TemplateParseError;
+ var TemplateParseResult = (function () {
+ function TemplateParseResult(templateAst, errors) {
+ this.templateAst = templateAst;
+ this.errors = errors;
+ }
+ return TemplateParseResult;
+ }());
+ exports.TemplateParseResult = TemplateParseResult;
+ var TemplateParser = (function () {
+ function TemplateParser(_exprParser, _schemaRegistry, _htmlParser, _console, transforms) {
+ this._exprParser = _exprParser;
+ this._schemaRegistry = _schemaRegistry;
+ this._htmlParser = _htmlParser;
+ this._console = _console;
+ this.transforms = transforms;
+ }
+ TemplateParser.prototype.parse = function (component, template, directives, pipes, templateUrl) {
+ var result = this.tryParse(component, template, directives, pipes, templateUrl);
+ var warnings = result.errors.filter(function (error) { return error.level === parse_util_1.ParseErrorLevel.WARNING; });
+ var errors = result.errors.filter(function (error) { return error.level === parse_util_1.ParseErrorLevel.FATAL; });
+ if (warnings.length > 0) {
+ this._console.warn("Template parse warnings:\n" + warnings.join('\n'));
+ }
+ if (errors.length > 0) {
+ var errorString = errors.join('\n');
+ throw new exceptions_1.BaseException("Template parse errors:\n" + errorString);
+ }
+ return result.templateAst;
+ };
+ TemplateParser.prototype.tryParse = function (component, template, directives, pipes, templateUrl) {
+ var htmlAstWithErrors = this._htmlParser.parse(template, templateUrl);
+ var errors = htmlAstWithErrors.errors;
+ var result;
+ if (htmlAstWithErrors.rootNodes.length > 0) {
+ var uniqDirectives = removeDuplicates(directives);
+ var uniqPipes = removeDuplicates(pipes);
+ var providerViewContext = new provider_parser_1.ProviderViewContext(component, htmlAstWithErrors.rootNodes[0].sourceSpan);
+ var parseVisitor = new TemplateParseVisitor(providerViewContext, uniqDirectives, uniqPipes, this._exprParser, this._schemaRegistry);
+ result = html_ast_1.htmlVisitAll(parseVisitor, htmlAstWithErrors.rootNodes, EMPTY_ELEMENT_CONTEXT);
+ errors = errors.concat(parseVisitor.errors).concat(providerViewContext.errors);
+ }
+ else {
+ result = [];
+ }
+ if (errors.length > 0) {
+ return new TemplateParseResult(result, errors);
+ }
+ if (lang_1.isPresent(this.transforms)) {
+ this.transforms.forEach(function (transform) { result = template_ast_1.templateVisitAll(transform, result); });
+ }
+ return new TemplateParseResult(result, errors);
+ };
+ TemplateParser.decorators = [
+ { type: core_1.Injectable },
+ ];
+ TemplateParser.ctorParameters = [
+ { type: parser_1.Parser, },
+ { type: element_schema_registry_1.ElementSchemaRegistry, },
+ { type: html_parser_1.HtmlParser, },
+ { type: core_private_1.Console, },
+ { type: undefined, decorators: [{ type: core_1.Optional }, { type: core_1.Inject, args: [exports.TEMPLATE_TRANSFORMS,] },] },
+ ];
+ return TemplateParser;
+ }());
+ exports.TemplateParser = TemplateParser;
+ var TemplateParseVisitor = (function () {
+ function TemplateParseVisitor(providerViewContext, directives, pipes, _exprParser, _schemaRegistry) {
+ var _this = this;
+ this.providerViewContext = providerViewContext;
+ this._exprParser = _exprParser;
+ this._schemaRegistry = _schemaRegistry;
+ this.errors = [];
+ this.directivesIndex = new Map();
+ this.ngContentCount = 0;
+ this.selectorMatcher = new selector_1.SelectorMatcher();
+ collection_1.ListWrapper.forEachWithIndex(directives, function (directive, index) {
+ var selector = selector_1.CssSelector.parse(directive.selector);
+ _this.selectorMatcher.addSelectables(selector, directive);
+ _this.directivesIndex.set(directive, index);
+ });
+ this.pipesByName = new Map();
+ pipes.forEach(function (pipe) { return _this.pipesByName.set(pipe.name, pipe); });
+ }
+ TemplateParseVisitor.prototype._reportError = function (message, sourceSpan, level) {
+ if (level === void 0) { level = parse_util_1.ParseErrorLevel.FATAL; }
+ this.errors.push(new TemplateParseError(message, sourceSpan, level));
+ };
+ TemplateParseVisitor.prototype._parseInterpolation = function (value, sourceSpan) {
+ var sourceInfo = sourceSpan.start.toString();
+ try {
+ var ast = this._exprParser.parseInterpolation(value, sourceInfo);
+ this._checkPipes(ast, sourceSpan);
+ if (lang_1.isPresent(ast) &&
+ ast.ast.expressions.length > core_private_1.MAX_INTERPOLATION_VALUES) {
+ throw new exceptions_1.BaseException("Only support at most " + core_private_1.MAX_INTERPOLATION_VALUES + " interpolation values!");
+ }
+ return ast;
+ }
+ catch (e) {
+ this._reportError("" + e, sourceSpan);
+ return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+ }
+ };
+ TemplateParseVisitor.prototype._parseAction = function (value, sourceSpan) {
+ var sourceInfo = sourceSpan.start.toString();
+ try {
+ var ast = this._exprParser.parseAction(value, sourceInfo);
+ this._checkPipes(ast, sourceSpan);
+ return ast;
+ }
+ catch (e) {
+ this._reportError("" + e, sourceSpan);
+ return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+ }
+ };
+ TemplateParseVisitor.prototype._parseBinding = function (value, sourceSpan) {
+ var sourceInfo = sourceSpan.start.toString();
+ try {
+ var ast = this._exprParser.parseBinding(value, sourceInfo);
+ this._checkPipes(ast, sourceSpan);
+ return ast;
+ }
+ catch (e) {
+ this._reportError("" + e, sourceSpan);
+ return this._exprParser.wrapLiteralPrimitive('ERROR', sourceInfo);
+ }
+ };
+ TemplateParseVisitor.prototype._parseTemplateBindings = function (value, sourceSpan) {
+ var _this = this;
+ var sourceInfo = sourceSpan.start.toString();
+ try {
+ var bindingsResult = this._exprParser.parseTemplateBindings(value, sourceInfo);
+ bindingsResult.templateBindings.forEach(function (binding) {
+ if (lang_1.isPresent(binding.expression)) {
+ _this._checkPipes(binding.expression, sourceSpan);
+ }
+ });
+ bindingsResult.warnings.forEach(function (warning) { _this._reportError(warning, sourceSpan, parse_util_1.ParseErrorLevel.WARNING); });
+ return bindingsResult.templateBindings;
+ }
+ catch (e) {
+ this._reportError("" + e, sourceSpan);
+ return [];
+ }
+ };
+ TemplateParseVisitor.prototype._checkPipes = function (ast, sourceSpan) {
+ var _this = this;
+ if (lang_1.isPresent(ast)) {
+ var collector = new PipeCollector();
+ ast.visit(collector);
+ collector.pipes.forEach(function (pipeName) {
+ if (!_this.pipesByName.has(pipeName)) {
+ _this._reportError("The pipe '" + pipeName + "' could not be found", sourceSpan);
+ }
+ });
+ }
+ };
+ TemplateParseVisitor.prototype.visitExpansion = function (ast, context) { return null; };
+ TemplateParseVisitor.prototype.visitExpansionCase = function (ast, context) { return null; };
+ TemplateParseVisitor.prototype.visitText = function (ast, parent) {
+ var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
+ var expr = this._parseInterpolation(ast.value, ast.sourceSpan);
+ if (lang_1.isPresent(expr)) {
+ return new template_ast_1.BoundTextAst(expr, ngContentIndex, ast.sourceSpan);
+ }
+ else {
+ return new template_ast_1.TextAst(ast.value, ngContentIndex, ast.sourceSpan);
+ }
+ };
+ TemplateParseVisitor.prototype.visitAttr = function (ast, contex) {
+ return new template_ast_1.AttrAst(ast.name, ast.value, ast.sourceSpan);
+ };
+ TemplateParseVisitor.prototype.visitComment = function (ast, context) { return null; };
+ TemplateParseVisitor.prototype.visitElement = function (element, parent) {
+ var _this = this;
+ var nodeName = element.name;
+ var preparsedElement = template_preparser_1.preparseElement(element);
+ if (preparsedElement.type === template_preparser_1.PreparsedElementType.SCRIPT ||
+ preparsedElement.type === template_preparser_1.PreparsedElementType.STYLE) {
+ // Skipping