@angular/language-service 6.1.6 → 6.1.10

package/bundles/language-service.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v6.1.6
+ * @license Angular v6.1.10
  * (c) 2010-2018 Google, Inc. https://angular.io/
  * License: MIT
  */
@@ -61,6 +61,21 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
         return __assign.apply(this, arguments);
     };
 
+    function __decorate(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;
+    }
+
+    function __param(paramIndex, decorator) {
+        return function (target, key) { decorator(target, key, paramIndex); }
+    }
+
+    function __metadata(metadataKey, metadataValue) {
+        if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+    }
+
     function __values(o) {
         var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
         if (m) return m.call(o);
@@ -445,61 +460,66 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
         };
         return HtmlTagDefinition;
     }());
+    var _DEFAULT_TAG_DEFINITION;
     // 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: TagContentType.RAW_TEXT }),
-        'script': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),
-        'title': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT }),
-        'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
-    };
-    var _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();
+    var TAG_DEFINITIONS;
     function getHtmlTagDefinition(tagName) {
+        if (!TAG_DEFINITIONS) {
+            _DEFAULT_TAG_DEFINITION = new HtmlTagDefinition();
+            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: TagContentType.RAW_TEXT }),
+                'script': new HtmlTagDefinition({ contentType: TagContentType.RAW_TEXT }),
+                'title': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT }),
+                'textarea': new HtmlTagDefinition({ contentType: TagContentType.ESCAPABLE_RAW_TEXT, ignoreFirstLf: true }),
+            };
+        }
         return TAG_DEFINITIONS[tagName.toLowerCase()] || _DEFAULT_TAG_DEFINITION;
     }
 
@@ -1144,7 +1164,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var VERSION = new Version('6.1.6');
+    var VERSION = new Version('6.1.10');
 
     /**
      * @license
@@ -12427,13 +12447,48 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
     //
     // =================================================================================================
     /** Map from tagName|propertyName SecurityContext. Properties applying to all tags use '*'. */
-    var SECURITY_SCHEMA = {};
+    var _SECURITY_SCHEMA;
+    function SECURITY_SCHEMA() {
+        if (!_SECURITY_SCHEMA) {
+            _SECURITY_SCHEMA = {};
+            // Case is insignificant below, all element and attribute names are lower-cased for lookup.
+            registerContext(SecurityContext.HTML, [
+                'iframe|srcdoc',
+                '*|innerHTML',
+                '*|outerHTML',
+            ]);
+            registerContext(SecurityContext.STYLE, ['*|style']);
+            // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.
+            registerContext(SecurityContext.URL, [
+                '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href',
+                'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action',
+                'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite',
+                'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src',
+            ]);
+            registerContext(SecurityContext.RESOURCE_URL, [
+                'applet|code',
+                'applet|codebase',
+                'base|href',
+                'embed|src',
+                'frame|src',
+                'head|profile',
+                'html|manifest',
+                'iframe|src',
+                'link|href',
+                'media|src',
+                'object|codebase',
+                'object|data',
+                'script|src',
+            ]);
+        }
+        return _SECURITY_SCHEMA;
+    }
     function registerContext(ctx, specs) {
         var e_1, _a;
         try {
             for (var specs_1 = __values(specs), specs_1_1 = specs_1.next(); !specs_1_1.done; specs_1_1 = specs_1.next()) {
                 var spec = specs_1_1.value;
-                SECURITY_SCHEMA[spec.toLowerCase()] = ctx;
+                _SECURITY_SCHEMA[spec.toLowerCase()] = ctx;
             }
         }
         catch (e_1_1) { e_1 = { error: e_1_1 }; }
@@ -12444,35 +12499,6 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             finally { if (e_1) throw e_1.error; }
         }
     }
-    // Case is insignificant below, all element and attribute names are lower-cased for lookup.
-    registerContext(SecurityContext.HTML, [
-        'iframe|srcdoc',
-        '*|innerHTML',
-        '*|outerHTML',
-    ]);
-    registerContext(SecurityContext.STYLE, ['*|style']);
-    // NB: no SCRIPT contexts here, they are never allowed due to the parser stripping them.
-    registerContext(SecurityContext.URL, [
-        '*|formAction', 'area|href', 'area|ping', 'audio|src', 'a|href',
-        'a|ping', 'blockquote|cite', 'body|background', 'del|cite', 'form|action',
-        'img|src', 'img|srcset', 'input|src', 'ins|cite', 'q|cite',
-        'source|src', 'source|srcset', 'track|src', 'video|poster', 'video|src',
-    ]);
-    registerContext(SecurityContext.RESOURCE_URL, [
-        'applet|code',
-        'applet|codebase',
-        'base|href',
-        'embed|src',
-        'frame|src',
-        'head|profile',
-        'html|manifest',
-        'iframe|src',
-        'link|href',
-        'media|src',
-        'object|codebase',
-        'object|data',
-        'script|src',
-    ]);
 
     /**
      * @license
@@ -12808,11 +12834,11 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             // property names do not have a security impact.
             tagName = tagName.toLowerCase();
             propName = propName.toLowerCase();
-            var ctx = SECURITY_SCHEMA[tagName + '|' + propName];
+            var ctx = SECURITY_SCHEMA()[tagName + '|' + propName];
             if (ctx) {
                 return ctx;
             }
-            ctx = SECURITY_SCHEMA['*|' + propName];
+            ctx = SECURITY_SCHEMA()['*|' + propName];
             return ctx ? ctx : SecurityContext.NONE;
         };
         DomElementSchemaRegistry.prototype.getMappedPropName = function (propName) { return _ATTR_TO_PROP[propName] || propName; };
@@ -13490,7 +13516,13 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
     var IDENT_EVENT_IDX = 10;
     var TEMPLATE_ATTR_PREFIX = '*';
     var CLASS_ATTR = 'class';
-    var TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];
+    var _TEXT_CSS_SELECTOR;
+    function TEXT_CSS_SELECTOR() {
+        if (!_TEXT_CSS_SELECTOR) {
+            _TEXT_CSS_SELECTOR = CssSelector.parse('*')[0];
+        }
+        return _TEXT_CSS_SELECTOR;
+    }
     var TemplateParseError = /** @class */ (function (_super) {
         __extends(TemplateParseError, _super);
         function TemplateParseError(message, span, level) {
@@ -13634,7 +13666,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
         TemplateParseVisitor.prototype.visitExpansion = function (expansion, context) { return null; };
         TemplateParseVisitor.prototype.visitExpansionCase = function (expansionCase, context) { return null; };
         TemplateParseVisitor.prototype.visitText = function (text, parent) {
-            var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
+            var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR());
             var valueNoNgsp = replaceNgsp(text.value);
             var expr = this._bindingParser.parseInterpolation(valueNoNgsp, text.sourceSpan);
             return expr ? new BoundTextAst(expr, ngContentIndex, text.sourceSpan) :
@@ -14040,7 +14072,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             return new AttrAst(attribute.name, attribute.value, attribute.sourceSpan);
         };
         NonBindableVisitor.prototype.visitText = function (text, parent) {
-            var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR);
+            var ngContentIndex = parent.findNgContentIndex(TEXT_CSS_SELECTOR());
             return new TextAst(text.value, ngContentIndex, text.sourceSpan);
         };
         NonBindableVisitor.prototype.visitExpansion = function (expansion, context) { return expansion; };
@@ -14664,6 +14696,16 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             this.map = new Map();
             this.referenceNameIndex = 0;
         }
+        Object.defineProperty(BindingScope, "ROOT_SCOPE", {
+            get: function () {
+                if (!BindingScope._ROOT_SCOPE) {
+                    BindingScope._ROOT_SCOPE = new BindingScope().set('$event', variable('$event'));
+                }
+                return BindingScope._ROOT_SCOPE;
+            },
+            enumerable: true,
+            configurable: true
+        });
         BindingScope.prototype.get = function (name) {
             var current = this;
             while (current) {
@@ -14714,7 +14756,6 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             var ref = "" + REFERENCE_PREFIX + current.referenceNameIndex++;
             return ref;
         };
-        BindingScope.ROOT_SCOPE = new BindingScope().set('$event', variable('$event'));
         return BindingScope;
     }());
 
@@ -22755,11 +22796,11 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * @usageNotes
      * ### Basic Example
      *
-     * #### Plain InjectionToken
+     * ### Plain InjectionToken
      *
      * {@example core/di/ts/injector_spec.ts region='InjectionToken'}
      *
-     * #### Tree-shakable InjectionToken
+     * ### Tree-shakable InjectionToken
      *
      * {@example core/di/ts/injector_spec.ts region='ShakableInjectionToken'}
      *
@@ -24203,6 +24244,9 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      *
      * See {@link Component#encapsulation encapsulation}.
      *
+     * @usageNotes
+     * ### Example
+     * {@example core/ts/metadata/encapsulation.ts region='longform'}
      */
     var ViewEncapsulation$1;
     (function (ViewEncapsulation) {
@@ -24234,9 +24278,6 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
          * For the DOM this means using modern [Shadow
          * DOM](https://w3c.github.io/webcomponents/spec/shadow/) and
          * creating a ShadowRoot for Component's Host Element.
-         *
-         * ### Example
-         * {@example core/ts/metadata/encapsulation.ts region='longform'}
          */
         ViewEncapsulation[ViewEncapsulation["ShadowDom"] = 3] = "ShadowDom";
     })(ViewEncapsulation$1 || (ViewEncapsulation$1 = {}));
@@ -24270,7 +24311,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
         }
         return Version;
     }());
-    var VERSION$2 = new Version$1('6.1.6');
+    var VERSION$2 = new Version$1('6.1.10');
 
     /**
      * @license
@@ -26514,7 +26555,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      */
     function getPromiseCtor(promiseCtor) {
         if (!promiseCtor) {
-            promiseCtor = config.Promise || Promise;
+            promiseCtor = Promise;
         }
         if (!promiseCtor) {
             throw new Error('no Promise impl found');
@@ -29717,6 +29758,31 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
         return mergeAll(concurrent)(fromArray(observables, scheduler));
     }
 
+    /**
+     * An Observable that emits no items to the Observer and never completes.
+     *
+     * <img src="./img/never.png" width="100%">
+     *
+     * A simple Observable that emits neither values nor errors nor the completion
+     * notification. It can be used for testing purposes or for composing with other
+     * Observables. Please note that by never emitting a complete notification, this
+     * Observable keeps the subscription from being disposed automatically.
+     * Subscriptions need to be manually disposed.
+     *
+     * @example <caption>Emit the number 7, then never emit anything else (not even complete).</caption>
+     * function info() {
+     *   console.log('Will not be called');
+     * }
+     * var result = NEVER.startWith(7);
+     * result.subscribe(x => console.log(x), info, info);
+     *
+     * @see {@link create}
+     * @see {@link EMPTY}
+     * @see {@link of}
+     * @see {@link throwError}
+     */
+    var NEVER = new Observable(noop$1);
+
     var __read$7 = (undefined && undefined.__read) || function (o, n) {
         var m = typeof Symbol === "function" && o[Symbol.iterator];
         if (!m) return o;
@@ -33828,13 +33894,11 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             }
             this.initialized = true;
         };
-        ApplicationInitStatus.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        ApplicationInitStatus.ctorParameters = function () { return [
-            { type: Array, decorators: [{ type: Inject, args: [APP_INITIALIZER,] }, { type: Optional }] }
-        ]; };
+        ApplicationInitStatus = __decorate([
+            Injectable(),
+            __param(0, Inject(APP_INITIALIZER)), __param(0, Optional()),
+            __metadata("design:paramtypes", [Array])
+        ], ApplicationInitStatus);
         return ApplicationInitStatus;
     }());
 
@@ -33915,9 +33979,9 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             // tslint:disable-next-line:no-console
             console.warn(message);
         };
-        Console.decorators = [
-            { type: Injectable }
-        ];
+        Console = __decorate([
+            Injectable()
+        ], Console);
         return Console;
     }());
 
@@ -33977,9 +34041,9 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
          * Returns the id for a given NgModule, if one is defined and known to the compiler.
          */
         Compiler.prototype.getModuleId = function (moduleType) { return undefined; };
-        Compiler.decorators = [
-            { type: Injectable }
-        ];
+        Compiler = __decorate([
+            Injectable()
+        ], Compiler);
         return Compiler;
     }());
     /**
@@ -34007,11 +34071,9 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * found in the LICENSE file at https://angular.io/license
      */
     /**
-     * Represents an instance of a Component created via a {@link ComponentFactory}.
-     *
-     * `ComponentRef` provides access to the Component Instance as well other objects related to this
-     * Component Instance and allows you to destroy the Component Instance via the {@link #destroy}
-     * method.
+     * Represents a component created by a `ComponentFactory`.
+     * Provides access to the component instance and related objects,
+     * and provides the means of destroying the instance.
      *
      */
     var ComponentRef = /** @class */ (function () {
@@ -34775,13 +34837,10 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             // TODO(juliemr): implement.
             return [];
         };
-        Testability.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        Testability.ctorParameters = function () { return [
-            { type: NgZone }
-        ]; };
+        Testability = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [NgZone])
+        ], Testability);
         return Testability;
     }());
     /**
@@ -34834,11 +34893,10 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             if (findInAncestors === void 0) { findInAncestors = true; }
             return _testabilityGetter.findTestabilityInTree(this, elem, findInAncestors);
         };
-        TestabilityRegistry.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        TestabilityRegistry.ctorParameters = function () { return []; };
+        TestabilityRegistry = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [])
+        ], TestabilityRegistry);
         return TestabilityRegistry;
     }());
     var _NoopGetTestability = /** @class */ (function () {
@@ -35075,13 +35133,10 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             enumerable: true,
             configurable: true
         });
-        PlatformRef.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        PlatformRef.ctorParameters = function () { return [
-            { type: Injector }
-        ]; };
+        PlatformRef = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [Injector])
+        ], PlatformRef);
         return PlatformRef;
     }());
     function getNgZone(ngZoneOption) {
@@ -35192,6 +35247,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             this.isStable =
                 merge(isCurrentlyStable, isStable.pipe(share()));
         }
+        ApplicationRef_1 = ApplicationRef;
         /**
          * Bootstrap a new component at the root level of the application.
          *
@@ -35255,7 +35311,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             if (this._runningTick) {
                 throw new Error('ApplicationRef.tick is called recursively');
             }
-            var scope = ApplicationRef._tickScope();
+            var scope = ApplicationRef_1._tickScope();
             try {
                 this._runningTick = true;
                 this._views.forEach(function (view) { return view.detectChanges(); });
@@ -35315,20 +35371,16 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             enumerable: true,
             configurable: true
         });
+        var ApplicationRef_1;
         /** @internal */
         ApplicationRef._tickScope = wtfCreateScope('ApplicationRef#tick()');
-        ApplicationRef.decorators = [
-            { type: Injectable }
-        ];
-        /** @nocollapse */
-        ApplicationRef.ctorParameters = function () { return [
-            { type: NgZone },
-            { type: Console },
-            { type: Injector },
-            { type: ErrorHandler },
-            { type: ComponentFactoryResolver },
-            { type: ApplicationInitStatus }
-        ]; };
+        ApplicationRef = ApplicationRef_1 = __decorate([
+            Injectable(),
+            __metadata("design:paramtypes", [NgZone, Console, Injector,
+                ErrorHandler,
+                ComponentFactoryResolver,
+                ApplicationInitStatus])
+        ], ApplicationRef);
         return ApplicationRef;
     }());
     function remove(list, el) {
@@ -35563,6 +35615,71 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    var _SEPARATOR = '#';
+    var FACTORY_CLASS_SUFFIX = 'NgFactory';
+    /**
+     * Configuration for SystemJsNgModuleLoader.
+     * token.
+     *
+     * @experimental
+     */
+    var SystemJsNgModuleLoaderConfig = /** @class */ (function () {
+        function SystemJsNgModuleLoaderConfig() {
+        }
+        return SystemJsNgModuleLoaderConfig;
+    }());
+    var DEFAULT_CONFIG = {
+        factoryPathPrefix: '',
+        factoryPathSuffix: '.ngfactory',
+    };
+    /**
+     * NgModuleFactoryLoader that uses SystemJS to load NgModuleFactory
+     * @experimental
+     */
+    var SystemJsNgModuleLoader = /** @class */ (function () {
+        function SystemJsNgModuleLoader(_compiler, config) {
+            this._compiler = _compiler;
+            this._config = config || DEFAULT_CONFIG;
+        }
+        SystemJsNgModuleLoader.prototype.load = function (path$$1) {
+            var offlineMode = this._compiler instanceof Compiler;
+            return offlineMode ? this.loadFactory(path$$1) : this.loadAndCompile(path$$1);
+        };
+        SystemJsNgModuleLoader.prototype.loadAndCompile = function (path$$1) {
+            var _this = this;
+            var _a = __read(path$$1.split(_SEPARATOR), 2), module = _a[0], exportName = _a[1];
+            if (exportName === undefined) {
+                exportName = 'default';
+            }
+            return System.import(module)
+                .then(function (module) { return module[exportName]; })
+                .then(function (type) { return checkNotEmpty(type, module, exportName); })
+                .then(function (type) { return _this._compiler.compileModuleAsync(type); });
+        };
+        SystemJsNgModuleLoader.prototype.loadFactory = function (path$$1) {
+            var _a = __read(path$$1.split(_SEPARATOR), 2), module = _a[0], exportName = _a[1];
+            var factoryClassSuffix = FACTORY_CLASS_SUFFIX;
+            if (exportName === undefined) {
+                exportName = 'default';
+                factoryClassSuffix = '';
+            }
+            return System.import(this._config.factoryPathPrefix + module + this._config.factoryPathSuffix)
+                .then(function (module) { return module[exportName + factoryClassSuffix]; })
+                .then(function (factory) { return checkNotEmpty(factory, module, exportName); });
+        };
+        SystemJsNgModuleLoader = __decorate([
+            Injectable(),
+            __param(1, Optional()),
+            __metadata("design:paramtypes", [Compiler, SystemJsNgModuleLoaderConfig])
+        ], SystemJsNgModuleLoader);
+        return SystemJsNgModuleLoader;
+    }());
+    function checkNotEmpty(value, modulePath, exportName) {
+        if (!value) {
+            throw new Error("Cannot find '" + exportName + "' in '" + modulePath + "'");
+        }
+        return value;
+    }
 
     /**
      * @license
@@ -35572,15 +35689,20 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * found in the LICENSE file at https://angular.io/license
      */
     /**
-     * Represents an Embedded Template that can be used to instantiate Embedded Views.
+     * Represents an embedded template that can be used to instantiate embedded views.
+     * To instantiate embedded views based on a template, use the `ViewContainerRef`
+     * method `createEmbeddedView()`.
+     *
+     * Access a `TemplateRef` instance by placing a directive on an `<ng-template>`
+     * element (or directive prefixed with `*`). The `TemplateRef` for the embedded view
+     * is injected into the constructor of the directive,
+     * using the `TemplateRef` token.
      *
-     * You can access a `TemplateRef`, in two ways. Via a directive placed on a `<ng-template>` element
-     * (or directive prefixed with `*`) and have the `TemplateRef` for this Embedded View injected into
-     * the constructor of the directive using the `TemplateRef` Token. Alternatively you can query for
-     * the `TemplateRef` from a Component or a Directive via {@link Query}.
+     * You can also use a `Query` to find a `TemplateRef` associated with
+     * a component or a directive.
      *
-     * To instantiate Embedded Views based on a Template, use {@link ViewContainerRef#
-     * createEmbeddedView}, which will create the View and attach it to the View Container.
+     * @see `ViewContainerRef`
+     * @see [Navigate the Component Tree with DI](guide/dependency-injection-navtree)
      *
      */
     var TemplateRef = /** @class */ (function () {
@@ -35597,21 +35719,17 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * found in the LICENSE file at https://angular.io/license
      */
     /**
-     * Represents a container where one or more Views can be attached.
+     * Represents a container where one or more views can be attached to a component.
      *
-     * The container can contain two kinds of Views. Host Views, created by instantiating a
-     * {@link Component} via {@link #createComponent}, and Embedded Views, created by instantiating an
-     * {@link TemplateRef Embedded Template} via {@link #createEmbeddedView}.
+     * Can contain *host views* (created by instantiating a
+     * component with the `createComponent()` method), and *embedded views*
+     * (created by instantiating a `TemplateRef` with the `createEmbeddedView()` method).
      *
-     * The location of the View Container within the containing View is specified by the Anchor
-     * `element`. Each View Container can have only one Anchor Element and each Anchor Element can only
-     * have a single View Container.
+     * A view container instance can contain other view containers,
+     * creating a [view hierarchy](guide/glossary#view-tree).
      *
-     * Root elements of Views attached to this container become siblings of the Anchor Element in
-     * the Rendered View.
-     *
-     * To access a `ViewContainerRef` of an Element, you can either place a {@link Directive} injected
-     * with `ViewContainerRef` on the Element, or you obtain it via a {@link ViewChild} query.
+     * @see `ComponentRef`
+     * @see `EmbeddedViewRef`
      *
      */
     var ViewContainerRef = /** @class */ (function () {
@@ -35665,7 +35783,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * when the `live` property is set to false, and reattaches it when the property
      * becomes true.
      *
-     * <code-example path="core/ts/change_detect/change-detection.ts" region="detach"></code-example>
+     * <code-example path="core/ts/change_detect/change-detection.ts" region="reattach"></code-example>
      *
      */
     var ChangeDetectorRef = /** @class */ (function () {
@@ -35681,6 +35799,14 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    /**
+     * Represents an Angular [view](guide/glossary#view),
+     * specifically the [host view](guide/glossary#view-tree) that is defined by a component.
+     * Also serves as the base class
+     * that adds destroy methods for [embedded views](guide/glossary#view-tree).
+     *
+     * @see `EmbeddedViewRef`
+     */
     var ViewRef = /** @class */ (function (_super) {
         __extends(ViewRef, _super);
         function ViewRef() {
@@ -35689,21 +35815,21 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
         return ViewRef;
     }(ChangeDetectorRef));
     /**
-     * Represents an Angular View.
+     * Represents an Angular [view](guide/glossary#view) in a view container.
+     * An [embedded view](guide/glossary#view-tree) can be referenced from a component
+     * other than the hosting component whose template defines it, or it can be defined
+     * independently by a `TemplateRef`.
      *
-     * <!-- TODO: move the next two paragraphs to the dev guide -->
-     * A View is a fundamental building block of the application UI. It is the smallest grouping of
-     * Elements which are created and destroyed together.
+     * Properties of elements in a view can change, but the structure (number and order) of elements in
+     * a view cannot. Change the structure of elements by inserting, moving, or
+     * removing nested views in a view container.
      *
-     * Properties of elements in a View can change, but the structure (number and order) of elements in
-     * a View cannot. Changing the structure of Elements can only be done by inserting, moving or
-     * removing nested Views via a `ViewContainerRef`. Each View can contain many View Containers.
-     * <!-- /TODO -->
+     * @see `ViewContainerRef`
      *
      * @usageNotes
-     * ### Example
      *
-     * Given this template...
+     * The following template breaks down into two separate `TemplateRef` instances,
+     * an outer one and an inner one.
      *
      * ```
      * Count: {{items.length}}
@@ -35712,9 +35838,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * </ul>
      * ```
      *
-     * We have two `TemplateRef`s:
-     *
-     * Outer `TemplateRef`:
+     * This is the outer `TemplateRef`:
      *
      * ```
      * Count: {{items.length}}
@@ -35723,15 +35847,13 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * </ul>
      * ```
      *
-     * Inner `TemplateRef`:
+     * This is the inner `TemplateRef`:
      *
      * ```
      *   <li>{{item}}</li>
      * ```
      *
-     * Notice that the original template is broken down into two separate `TemplateRef`s.
-     *
-     * The outer/inner `TemplateRef`s are then assembled into views like so:
+     * The outer and inner `TemplateRef` instances are assembled into views as follows:
      *
      * ```
      * <!-- ViewRef: outer-0 -->
@@ -37295,6 +37417,10 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
     function _localeFactory(locale) {
         return locale || 'en-US';
     }
+    /**
+     * A built-in [dependency injection token](guide/glossary#di-token)
+     * that is used to configure the root injector for bootstrapping.
+     */
     var APPLICATION_MODULE_PROVIDERS = [
         {
             provide: ApplicationRef,
@@ -37316,6 +37442,26 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
             deps: [[new Inject(LOCALE_ID), new Optional(), new SkipSelf()]]
         },
     ];
+    /**
+     * Configures the root injector for an app with
+     * providers of `@angular/core` dependencies that `ApplicationRef` needs
+     * to bootstrap components.
+     *
+     * Re-exported by `BrowserModule`, which is included automatically in the root
+     * `AppModule` when you create a new app with the CLI `new` command.
+     *
+     * @experimental
+     */
+    var ApplicationModule = /** @class */ (function () {
+        // Inject ApplicationRef to make it eager...
+        function ApplicationModule(appRef) {
+        }
+        ApplicationModule = __decorate([
+            NgModule({ providers: APPLICATION_MODULE_PROVIDERS }),
+            __metadata("design:paramtypes", [ApplicationRef])
+        ], ApplicationModule);
+        return ApplicationModule;
+    }());
 
     /**
      * @license
@@ -41098,34 +41244,55 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var ngDevModeResetPerfCounters = (typeof ngDevMode == 'undefined' && (function (global) {
-        function ngDevModeResetPerfCounters() {
-            global['ngDevMode'] = {
-                firstTemplatePass: 0,
-                tNode: 0,
-                tView: 0,
-                rendererCreateTextNode: 0,
-                rendererSetText: 0,
-                rendererCreateElement: 0,
-                rendererAddEventListener: 0,
-                rendererSetAttribute: 0,
-                rendererRemoveAttribute: 0,
-                rendererSetProperty: 0,
-                rendererSetClassName: 0,
-                rendererAddClass: 0,
-                rendererRemoveClass: 0,
-                rendererSetStyle: 0,
-                rendererRemoveStyle: 0,
-                rendererDestroy: 0,
-                rendererDestroyNode: 0,
-                rendererMoveNode: 0,
-                rendererRemoveNode: 0,
-            };
+    function ngDevModeResetPerfCounters() {
+        var newCounters = {
+            firstTemplatePass: 0,
+            tNode: 0,
+            tView: 0,
+            rendererCreateTextNode: 0,
+            rendererSetText: 0,
+            rendererCreateElement: 0,
+            rendererAddEventListener: 0,
+            rendererSetAttribute: 0,
+            rendererRemoveAttribute: 0,
+            rendererSetProperty: 0,
+            rendererSetClassName: 0,
+            rendererAddClass: 0,
+            rendererRemoveClass: 0,
+            rendererSetStyle: 0,
+            rendererRemoveStyle: 0,
+            rendererDestroy: 0,
+            rendererDestroyNode: 0,
+            rendererMoveNode: 0,
+            rendererRemoveNode: 0,
+        };
+        // NOTE: Under Ivy we may have both window & global defined in the Node
+        //    environment since ensureDocument() in render3.ts sets global.window.
+        if (typeof window != 'undefined') {
+            // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.
+            window['ngDevMode'] = newCounters;
+        }
+        if (typeof global != 'undefined') {
+            // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.
+            global['ngDevMode'] = newCounters;
+        }
+        if (typeof self != 'undefined') {
+            // Make sure to refer to ngDevMode as ['ngDevMode'] for closure.
+            self['ngDevMode'] = newCounters;
         }
+        return newCounters;
+    }
+    /**
+     * This checks to see if the `ngDevMode` has been set. If yes,
+     * than we honor it, otherwise we default to dev mode with additional checks.
+     *
+     * The idea is that unless we are doing production build where we explicitly
+     * set `ngDevMode == false` we should be helping the developer by providing
+     * as much early warning and errors as possible.
+     */
+    if (typeof ngDevMode === 'undefined' || ngDevMode) {
         ngDevModeResetPerfCounters();
-        return ngDevModeResetPerfCounters;
-    })(typeof window != 'undefined' && window || typeof self != 'undefined' && self ||
-        typeof global != 'undefined' && global));
+    }
 
     /** Called when directives inject each other (creating a circular dependency) */
 
@@ -42971,7 +43138,51 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    /**
+     * Creates (or gets an existing) injector for a given element or container.
+     *
+     * @param node for which an injector should be retrieved / created.
+     * @returns Node injector
+     */
+    function getOrCreateNodeInjectorForNode(node) {
+        var nodeInjector = node.nodeInjector;
+        var parent = getParentLNode(node);
+        var parentInjector = parent && parent.nodeInjector;
+        if (nodeInjector != parentInjector) {
+            return nodeInjector;
+        }
+        return node.nodeInjector = {
+            parent: parentInjector,
+            node: node,
+            bf0: 0,
+            bf1: 0,
+            bf2: 0,
+            bf3: 0,
+            bf4: 0,
+            bf5: 0,
+            bf6: 0,
+            bf7: 0,
+            cbf0: parentInjector == null ? 0 : parentInjector.cbf0 | parentInjector.bf0,
+            cbf1: parentInjector == null ? 0 : parentInjector.cbf1 | parentInjector.bf1,
+            cbf2: parentInjector == null ? 0 : parentInjector.cbf2 | parentInjector.bf2,
+            cbf3: parentInjector == null ? 0 : parentInjector.cbf3 | parentInjector.bf3,
+            cbf4: parentInjector == null ? 0 : parentInjector.cbf4 | parentInjector.bf4,
+            cbf5: parentInjector == null ? 0 : parentInjector.cbf5 | parentInjector.bf5,
+            cbf6: parentInjector == null ? 0 : parentInjector.cbf6 | parentInjector.bf6,
+            cbf7: parentInjector == null ? 0 : parentInjector.cbf7 | parentInjector.bf7,
+            templateRef: null,
+            viewContainerRef: null,
+            elementRef: null,
+            changeDetectorRef: null,
+        };
+    }
     var componentFactoryResolver = new ComponentFactoryResolver$1();
+    var ReadFromInjectorFn = /** @class */ (function () {
+        function ReadFromInjectorFn(read) {
+            this.read = read;
+        }
+        return ReadFromInjectorFn;
+    }());
     /**
      * A ref to a container that enables adding and removing views from that container
      * imperatively.
@@ -43181,6 +43392,210 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
+    var LQueries_ = /** @class */ (function () {
+        function LQueries_(deep) {
+            this.shallow = null;
+            this.deep = null;
+            this.deep = deep == null ? null : deep;
+        }
+        LQueries_.prototype.track = function (queryList, predicate, descend, read) {
+            if (descend) {
+                this.deep = createQuery$1(this.deep, queryList, predicate, read != null ? read : null);
+            }
+            else {
+                this.shallow = createQuery$1(this.shallow, queryList, predicate, read != null ? read : null);
+            }
+        };
+        LQueries_.prototype.clone = function () { return this.deep ? new LQueries_(this.deep) : null; };
+        LQueries_.prototype.child = function () {
+            if (this.deep === null) {
+                // if we don't have any deep queries then no need to track anything more.
+                return null;
+            }
+            if (this.shallow === null) {
+                // DeepQuery: We can reuse the current state if the child state would be same as current
+                // state.
+                return this;
+            }
+            else {
+                // We need to create new state
+                return new LQueries_(this.deep);
+            }
+        };
+        LQueries_.prototype.container = function () {
+            var result = null;
+            var query = this.deep;
+            while (query) {
+                var containerValues = []; // prepare room for views
+                query.values.push(containerValues);
+                var clonedQuery = {
+                    next: null,
+                    list: query.list,
+                    predicate: query.predicate,
+                    values: containerValues,
+                    containerValues: null
+                };
+                clonedQuery.next = result;
+                result = clonedQuery;
+                query = query.next;
+            }
+            return result ? new LQueries_(result) : null;
+        };
+        LQueries_.prototype.createView = function () {
+            var result = null;
+            var query = this.deep;
+            while (query) {
+                var clonedQuery = {
+                    next: null,
+                    list: query.list,
+                    predicate: query.predicate,
+                    values: [],
+                    containerValues: query.values
+                };
+                clonedQuery.next = result;
+                result = clonedQuery;
+                query = query.next;
+            }
+            return result ? new LQueries_(result) : null;
+        };
+        LQueries_.prototype.insertView = function (index) {
+            var query = this.deep;
+            while (query) {
+                ngDevMode &&
+                    assertDefined(query.containerValues, 'View queries need to have a pointer to container values.');
+                query.containerValues.splice(index, 0, query.values);
+                query = query.next;
+            }
+        };
+        LQueries_.prototype.addNode = function (node) {
+            add(this.shallow, node);
+            add(this.deep, node);
+        };
+        LQueries_.prototype.removeView = function () {
+            var query = this.deep;
+            while (query) {
+                ngDevMode &&
+                    assertDefined(query.containerValues, 'View queries need to have a pointer to container values.');
+                var containerValues = query.containerValues;
+                var viewValuesIdx = containerValues.indexOf(query.values);
+                var removed = containerValues.splice(viewValuesIdx, 1);
+                // mark a query as dirty only when removed view had matching modes
+                ngDevMode && assertEqual(removed.length, 1, 'removed.length');
+                if (removed[0].length) {
+                    query.list.setDirty();
+                }
+                query = query.next;
+            }
+        };
+        return LQueries_;
+    }());
+    /**
+     * Iterates over local names for a given node and returns directive index
+     * (or -1 if a local name points to an element).
+     *
+     * @param tNode static data of a node to check
+     * @param selector selector to match
+     * @returns directive index, -1 or null if a selector didn't match any of the local names
+     */
+    function getIdxOfMatchingSelector(tNode, selector) {
+        var localNames = tNode.localNames;
+        if (localNames) {
+            for (var i = 0; i < localNames.length; i += 2) {
+                if (localNames[i] === selector) {
+                    return localNames[i + 1];
+                }
+            }
+        }
+        return null;
+    }
+    /**
+     * Iterates over all the directives for a node and returns index of a directive for a given type.
+     *
+     * @param node Node on which directives are present.
+     * @param type Type of a directive to look for.
+     * @returns Index of a found directive or null when none found.
+     */
+    function getIdxOfMatchingDirective(node, type) {
+        var defs = node.view[TVIEW].directives;
+        var flags = node.tNode.flags;
+        var count = flags & 4095 /* DirectiveCountMask */;
+        var start = flags >> 14 /* DirectiveStartingIndexShift */;
+        var end = start + count;
+        for (var i = start; i < end; i++) {
+            var def = defs[i];
+            if (def.type === type && def.diPublic) {
+                return i;
+            }
+        }
+        return null;
+    }
+    function readFromNodeInjector(nodeInjector, node, read, directiveIdx) {
+        if (read instanceof ReadFromInjectorFn) {
+            return read.read(nodeInjector, node, directiveIdx);
+        }
+        else {
+            var matchingIdx = getIdxOfMatchingDirective(node, read);
+            if (matchingIdx !== null) {
+                return node.view[DIRECTIVES][matchingIdx];
+            }
+        }
+        return null;
+    }
+    function add(query, node) {
+        var nodeInjector = getOrCreateNodeInjectorForNode(node);
+        while (query) {
+            var predicate = query.predicate;
+            var type = predicate.type;
+            if (type) {
+                var directiveIdx = getIdxOfMatchingDirective(node, type);
+                if (directiveIdx !== null) {
+                    // a node is matching a predicate - determine what to read
+                    // if read token and / or strategy is not specified, use type as read token
+                    var result = readFromNodeInjector(nodeInjector, node, predicate.read || type, directiveIdx);
+                    if (result !== null) {
+                        addMatch(query, result);
+                    }
+                }
+            }
+            else {
+                var selector = predicate.selector;
+                for (var i = 0; i < selector.length; i++) {
+                    var directiveIdx = getIdxOfMatchingSelector(node.tNode, selector[i]);
+                    if (directiveIdx !== null) {
+                        // a node is matching a predicate - determine what to read
+                        // note that queries using name selector must specify read strategy
+                        ngDevMode && assertDefined(predicate.read, 'the node should have a predicate');
+                        var result = readFromNodeInjector(nodeInjector, node, predicate.read, directiveIdx);
+                        if (result !== null) {
+                            addMatch(query, result);
+                        }
+                    }
+                }
+            }
+            query = query.next;
+        }
+    }
+    function addMatch(query, matchingValue) {
+        query.values.push(matchingValue);
+        query.list.setDirty();
+    }
+    function createPredicate(predicate, read) {
+        var isArray = Array.isArray(predicate);
+        return {
+            type: isArray ? null : predicate,
+            selector: isArray ? predicate : null,
+            read: read
+        };
+    }
+    function createQuery$1(previous, queryList, predicate, read) {
+        return {
+            next: previous,
+            list: queryList,
+            predicate: createPredicate(predicate, read),
+            values: queryList._valuesTree,
+            containerValues: null
+        };
+    }
     var QueryList_ = /** @class */ (function () {
         function QueryList_() {
             this.dirty = true;
@@ -44308,7 +44723,7 @@ define(['exports', 'fs', 'path', 'typescript'], function (exports, fs, path, ts)
      * Use of this source code is governed by an MIT-style license that can be
      * found in the LICENSE file at https://angular.io/license
      */
-    var VERSION$3 = new Version$1('6.1.6');
+    var VERSION$3 = new Version$1('6.1.10');
 
     /**
      * @license