@angular/language-service 8.0.0-rc.4 → 8.0.2

package/bundles/language-service.umd.js

@@ -1,5 +1,5 @@
 /**
- * @license Angular v8.0.0-rc.4
+ * @license Angular v8.0.2
  * (c) 2010-2019 Google LLC. https://angular.io/
  * License: MIT
  */
@@ -2847,11 +2847,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             name: 'ɵregisterModuleFactory',
             moduleName: CORE,
         };
-        Identifiers.inject = { name: 'Δinject', moduleName: CORE };
+        Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE };
         Identifiers.INJECTOR = { name: 'INJECTOR', moduleName: CORE };
         Identifiers.Injector = { name: 'Injector', moduleName: CORE };
-        Identifiers.ΔdefineInjectable = { name: 'ΔdefineInjectable', moduleName: CORE };
-        Identifiers.InjectableDef = { name: 'ΔInjectableDef', moduleName: CORE };
+        Identifiers.ɵɵdefineInjectable = { name: 'ɵɵdefineInjectable', moduleName: CORE };
+        Identifiers.InjectableDef = { name: 'ɵɵInjectableDef', moduleName: CORE };
         Identifiers.ViewEncapsulation = {
             name: 'ViewEncapsulation',
             moduleName: CORE,
@@ -3355,159 +3355,159 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         Identifiers.TRANSFORM_METHOD = 'transform';
         Identifiers.PATCH_DEPS = 'patchedDeps';
         /* Instructions */
-        Identifiers.namespaceHTML = { name: 'ΔnamespaceHTML', moduleName: CORE$1 };
-        Identifiers.namespaceMathML = { name: 'ΔnamespaceMathML', moduleName: CORE$1 };
-        Identifiers.namespaceSVG = { name: 'ΔnamespaceSVG', moduleName: CORE$1 };
-        Identifiers.element = { name: 'Δelement', moduleName: CORE$1 };
-        Identifiers.elementStart = { name: 'ΔelementStart', moduleName: CORE$1 };
-        Identifiers.elementEnd = { name: 'ΔelementEnd', moduleName: CORE$1 };
-        Identifiers.elementProperty = { name: 'ΔelementProperty', moduleName: CORE$1 };
-        Identifiers.select = { name: 'Δselect', moduleName: CORE$1 };
-        Identifiers.componentHostSyntheticProperty = { name: 'ΔcomponentHostSyntheticProperty', moduleName: CORE$1 };
-        Identifiers.componentHostSyntheticListener = { name: 'ΔcomponentHostSyntheticListener', moduleName: CORE$1 };
-        Identifiers.elementAttribute = { name: 'ΔelementAttribute', moduleName: CORE$1 };
-        Identifiers.elementClassProp = { name: 'ΔelementClassProp', moduleName: CORE$1 };
-        Identifiers.elementContainerStart = { name: 'ΔelementContainerStart', moduleName: CORE$1 };
-        Identifiers.elementContainerEnd = { name: 'ΔelementContainerEnd', moduleName: CORE$1 };
-        Identifiers.elementStyling = { name: 'ΔelementStyling', moduleName: CORE$1 };
-        Identifiers.elementStylingMap = { name: 'ΔelementStylingMap', moduleName: CORE$1 };
-        Identifiers.elementStyleProp = { name: 'ΔelementStyleProp', moduleName: CORE$1 };
-        Identifiers.elementStylingApply = { name: 'ΔelementStylingApply', moduleName: CORE$1 };
-        Identifiers.elementHostAttrs = { name: 'ΔelementHostAttrs', moduleName: CORE$1 };
-        Identifiers.elementHostStyling = { name: 'ΔelementHostStyling', moduleName: CORE$1 };
-        Identifiers.elementHostStylingMap = { name: 'ΔelementHostStylingMap', moduleName: CORE$1 };
-        Identifiers.elementHostStyleProp = { name: 'ΔelementHostStyleProp', moduleName: CORE$1 };
-        Identifiers.elementHostClassProp = { name: 'ΔelementHostClassProp', moduleName: CORE$1 };
-        Identifiers.elementHostStylingApply = { name: 'ΔelementHostStylingApply', moduleName: CORE$1 };
-        Identifiers.containerCreate = { name: 'Δcontainer', moduleName: CORE$1 };
-        Identifiers.nextContext = { name: 'ΔnextContext', moduleName: CORE$1 };
-        Identifiers.templateCreate = { name: 'Δtemplate', moduleName: CORE$1 };
-        Identifiers.text = { name: 'Δtext', moduleName: CORE$1 };
-        Identifiers.textBinding = { name: 'ΔtextBinding', moduleName: CORE$1 };
-        Identifiers.bind = { name: 'Δbind', moduleName: CORE$1 };
-        Identifiers.enableBindings = { name: 'ΔenableBindings', moduleName: CORE$1 };
-        Identifiers.disableBindings = { name: 'ΔdisableBindings', moduleName: CORE$1 };
-        Identifiers.allocHostVars = { name: 'ΔallocHostVars', moduleName: CORE$1 };
-        Identifiers.getCurrentView = { name: 'ΔgetCurrentView', moduleName: CORE$1 };
-        Identifiers.restoreView = { name: 'ΔrestoreView', moduleName: CORE$1 };
-        Identifiers.interpolation1 = { name: 'Δinterpolation1', moduleName: CORE$1 };
-        Identifiers.interpolation2 = { name: 'Δinterpolation2', moduleName: CORE$1 };
-        Identifiers.interpolation3 = { name: 'Δinterpolation3', moduleName: CORE$1 };
-        Identifiers.interpolation4 = { name: 'Δinterpolation4', moduleName: CORE$1 };
-        Identifiers.interpolation5 = { name: 'Δinterpolation5', moduleName: CORE$1 };
-        Identifiers.interpolation6 = { name: 'Δinterpolation6', moduleName: CORE$1 };
-        Identifiers.interpolation7 = { name: 'Δinterpolation7', moduleName: CORE$1 };
-        Identifiers.interpolation8 = { name: 'Δinterpolation8', moduleName: CORE$1 };
-        Identifiers.interpolationV = { name: 'ΔinterpolationV', moduleName: CORE$1 };
-        Identifiers.pureFunction0 = { name: 'ΔpureFunction0', moduleName: CORE$1 };
-        Identifiers.pureFunction1 = { name: 'ΔpureFunction1', moduleName: CORE$1 };
-        Identifiers.pureFunction2 = { name: 'ΔpureFunction2', moduleName: CORE$1 };
-        Identifiers.pureFunction3 = { name: 'ΔpureFunction3', moduleName: CORE$1 };
-        Identifiers.pureFunction4 = { name: 'ΔpureFunction4', moduleName: CORE$1 };
-        Identifiers.pureFunction5 = { name: 'ΔpureFunction5', moduleName: CORE$1 };
-        Identifiers.pureFunction6 = { name: 'ΔpureFunction6', moduleName: CORE$1 };
-        Identifiers.pureFunction7 = { name: 'ΔpureFunction7', moduleName: CORE$1 };
-        Identifiers.pureFunction8 = { name: 'ΔpureFunction8', moduleName: CORE$1 };
-        Identifiers.pureFunctionV = { name: 'ΔpureFunctionV', moduleName: CORE$1 };
-        Identifiers.pipeBind1 = { name: 'ΔpipeBind1', moduleName: CORE$1 };
-        Identifiers.pipeBind2 = { name: 'ΔpipeBind2', moduleName: CORE$1 };
-        Identifiers.pipeBind3 = { name: 'ΔpipeBind3', moduleName: CORE$1 };
-        Identifiers.pipeBind4 = { name: 'ΔpipeBind4', moduleName: CORE$1 };
-        Identifiers.pipeBindV = { name: 'ΔpipeBindV', moduleName: CORE$1 };
-        Identifiers.property = { name: 'Δproperty', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate = { name: 'ΔpropertyInterpolate', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate1 = { name: 'ΔpropertyInterpolate1', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate2 = { name: 'ΔpropertyInterpolate2', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate3 = { name: 'ΔpropertyInterpolate3', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate4 = { name: 'ΔpropertyInterpolate4', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate5 = { name: 'ΔpropertyInterpolate5', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate6 = { name: 'ΔpropertyInterpolate6', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate7 = { name: 'ΔpropertyInterpolate7', moduleName: CORE$1 };
-        Identifiers.propertyInterpolate8 = { name: 'ΔpropertyInterpolate8', moduleName: CORE$1 };
-        Identifiers.propertyInterpolateV = { name: 'ΔpropertyInterpolateV', moduleName: CORE$1 };
-        Identifiers.i18n = { name: 'Δi18n', moduleName: CORE$1 };
-        Identifiers.i18nAttributes = { name: 'Δi18nAttributes', moduleName: CORE$1 };
-        Identifiers.i18nExp = { name: 'Δi18nExp', moduleName: CORE$1 };
-        Identifiers.i18nStart = { name: 'Δi18nStart', moduleName: CORE$1 };
-        Identifiers.i18nEnd = { name: 'Δi18nEnd', moduleName: CORE$1 };
-        Identifiers.i18nApply = { name: 'Δi18nApply', moduleName: CORE$1 };
-        Identifiers.i18nPostprocess = { name: 'Δi18nPostprocess', moduleName: CORE$1 };
-        Identifiers.i18nLocalize = { name: 'Δi18nLocalize', moduleName: CORE$1 };
-        Identifiers.load = { name: 'Δload', moduleName: CORE$1 };
-        Identifiers.pipe = { name: 'Δpipe', moduleName: CORE$1 };
-        Identifiers.projection = { name: 'Δprojection', moduleName: CORE$1 };
-        Identifiers.projectionDef = { name: 'ΔprojectionDef', moduleName: CORE$1 };
-        Identifiers.reference = { name: 'Δreference', moduleName: CORE$1 };
-        Identifiers.inject = { name: 'Δinject', moduleName: CORE$1 };
-        Identifiers.injectAttribute = { name: 'ΔinjectAttribute', moduleName: CORE$1 };
-        Identifiers.directiveInject = { name: 'ΔdirectiveInject', moduleName: CORE$1 };
-        Identifiers.templateRefExtractor = { name: 'ΔtemplateRefExtractor', moduleName: CORE$1 };
-        Identifiers.resolveWindow = { name: 'ΔresolveWindow', moduleName: CORE$1 };
-        Identifiers.resolveDocument = { name: 'ΔresolveDocument', moduleName: CORE$1 };
-        Identifiers.resolveBody = { name: 'ΔresolveBody', moduleName: CORE$1 };
-        Identifiers.defineBase = { name: 'ΔdefineBase', moduleName: CORE$1 };
+        Identifiers.namespaceHTML = { name: 'ɵɵnamespaceHTML', moduleName: CORE$1 };
+        Identifiers.namespaceMathML = { name: 'ɵɵnamespaceMathML', moduleName: CORE$1 };
+        Identifiers.namespaceSVG = { name: 'ɵɵnamespaceSVG', moduleName: CORE$1 };
+        Identifiers.element = { name: 'ɵɵelement', moduleName: CORE$1 };
+        Identifiers.elementStart = { name: 'ɵɵelementStart', moduleName: CORE$1 };
+        Identifiers.elementEnd = { name: 'ɵɵelementEnd', moduleName: CORE$1 };
+        Identifiers.elementProperty = { name: 'ɵɵelementProperty', moduleName: CORE$1 };
+        Identifiers.select = { name: 'ɵɵselect', moduleName: CORE$1 };
+        Identifiers.componentHostSyntheticProperty = { name: 'ɵɵcomponentHostSyntheticProperty', moduleName: CORE$1 };
+        Identifiers.componentHostSyntheticListener = { name: 'ɵɵcomponentHostSyntheticListener', moduleName: CORE$1 };
+        Identifiers.elementAttribute = { name: 'ɵɵelementAttribute', moduleName: CORE$1 };
+        Identifiers.elementClassProp = { name: 'ɵɵelementClassProp', moduleName: CORE$1 };
+        Identifiers.elementContainerStart = { name: 'ɵɵelementContainerStart', moduleName: CORE$1 };
+        Identifiers.elementContainerEnd = { name: 'ɵɵelementContainerEnd', moduleName: CORE$1 };
+        Identifiers.elementStyling = { name: 'ɵɵelementStyling', moduleName: CORE$1 };
+        Identifiers.elementStylingMap = { name: 'ɵɵelementStylingMap', moduleName: CORE$1 };
+        Identifiers.elementStyleProp = { name: 'ɵɵelementStyleProp', moduleName: CORE$1 };
+        Identifiers.elementStylingApply = { name: 'ɵɵelementStylingApply', moduleName: CORE$1 };
+        Identifiers.elementHostAttrs = { name: 'ɵɵelementHostAttrs', moduleName: CORE$1 };
+        Identifiers.elementHostStyling = { name: 'ɵɵelementHostStyling', moduleName: CORE$1 };
+        Identifiers.elementHostStylingMap = { name: 'ɵɵelementHostStylingMap', moduleName: CORE$1 };
+        Identifiers.elementHostStyleProp = { name: 'ɵɵelementHostStyleProp', moduleName: CORE$1 };
+        Identifiers.elementHostClassProp = { name: 'ɵɵelementHostClassProp', moduleName: CORE$1 };
+        Identifiers.elementHostStylingApply = { name: 'ɵɵelementHostStylingApply', moduleName: CORE$1 };
+        Identifiers.containerCreate = { name: 'ɵɵcontainer', moduleName: CORE$1 };
+        Identifiers.nextContext = { name: 'ɵɵnextContext', moduleName: CORE$1 };
+        Identifiers.templateCreate = { name: 'ɵɵtemplate', moduleName: CORE$1 };
+        Identifiers.text = { name: 'ɵɵtext', moduleName: CORE$1 };
+        Identifiers.textBinding = { name: 'ɵɵtextBinding', moduleName: CORE$1 };
+        Identifiers.bind = { name: 'ɵɵbind', moduleName: CORE$1 };
+        Identifiers.enableBindings = { name: 'ɵɵenableBindings', moduleName: CORE$1 };
+        Identifiers.disableBindings = { name: 'ɵɵdisableBindings', moduleName: CORE$1 };
+        Identifiers.allocHostVars = { name: 'ɵɵallocHostVars', moduleName: CORE$1 };
+        Identifiers.getCurrentView = { name: 'ɵɵgetCurrentView', moduleName: CORE$1 };
+        Identifiers.restoreView = { name: 'ɵɵrestoreView', moduleName: CORE$1 };
+        Identifiers.interpolation1 = { name: 'ɵɵinterpolation1', moduleName: CORE$1 };
+        Identifiers.interpolation2 = { name: 'ɵɵinterpolation2', moduleName: CORE$1 };
+        Identifiers.interpolation3 = { name: 'ɵɵinterpolation3', moduleName: CORE$1 };
+        Identifiers.interpolation4 = { name: 'ɵɵinterpolation4', moduleName: CORE$1 };
+        Identifiers.interpolation5 = { name: 'ɵɵinterpolation5', moduleName: CORE$1 };
+        Identifiers.interpolation6 = { name: 'ɵɵinterpolation6', moduleName: CORE$1 };
+        Identifiers.interpolation7 = { name: 'ɵɵinterpolation7', moduleName: CORE$1 };
+        Identifiers.interpolation8 = { name: 'ɵɵinterpolation8', moduleName: CORE$1 };
+        Identifiers.interpolationV = { name: 'ɵɵinterpolationV', moduleName: CORE$1 };
+        Identifiers.pureFunction0 = { name: 'ɵɵpureFunction0', moduleName: CORE$1 };
+        Identifiers.pureFunction1 = { name: 'ɵɵpureFunction1', moduleName: CORE$1 };
+        Identifiers.pureFunction2 = { name: 'ɵɵpureFunction2', moduleName: CORE$1 };
+        Identifiers.pureFunction3 = { name: 'ɵɵpureFunction3', moduleName: CORE$1 };
+        Identifiers.pureFunction4 = { name: 'ɵɵpureFunction4', moduleName: CORE$1 };
+        Identifiers.pureFunction5 = { name: 'ɵɵpureFunction5', moduleName: CORE$1 };
+        Identifiers.pureFunction6 = { name: 'ɵɵpureFunction6', moduleName: CORE$1 };
+        Identifiers.pureFunction7 = { name: 'ɵɵpureFunction7', moduleName: CORE$1 };
+        Identifiers.pureFunction8 = { name: 'ɵɵpureFunction8', moduleName: CORE$1 };
+        Identifiers.pureFunctionV = { name: 'ɵɵpureFunctionV', moduleName: CORE$1 };
+        Identifiers.pipeBind1 = { name: 'ɵɵpipeBind1', moduleName: CORE$1 };
+        Identifiers.pipeBind2 = { name: 'ɵɵpipeBind2', moduleName: CORE$1 };
+        Identifiers.pipeBind3 = { name: 'ɵɵpipeBind3', moduleName: CORE$1 };
+        Identifiers.pipeBind4 = { name: 'ɵɵpipeBind4', moduleName: CORE$1 };
+        Identifiers.pipeBindV = { name: 'ɵɵpipeBindV', moduleName: CORE$1 };
+        Identifiers.property = { name: 'ɵɵproperty', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate = { name: 'ɵɵpropertyInterpolate', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate1 = { name: 'ɵɵpropertyInterpolate1', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate2 = { name: 'ɵɵpropertyInterpolate2', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate3 = { name: 'ɵɵpropertyInterpolate3', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate4 = { name: 'ɵɵpropertyInterpolate4', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate5 = { name: 'ɵɵpropertyInterpolate5', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate6 = { name: 'ɵɵpropertyInterpolate6', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate7 = { name: 'ɵɵpropertyInterpolate7', moduleName: CORE$1 };
+        Identifiers.propertyInterpolate8 = { name: 'ɵɵpropertyInterpolate8', moduleName: CORE$1 };
+        Identifiers.propertyInterpolateV = { name: 'ɵɵpropertyInterpolateV', moduleName: CORE$1 };
+        Identifiers.i18n = { name: 'ɵɵi18n', moduleName: CORE$1 };
+        Identifiers.i18nAttributes = { name: 'ɵɵi18nAttributes', moduleName: CORE$1 };
+        Identifiers.i18nExp = { name: 'ɵɵi18nExp', moduleName: CORE$1 };
+        Identifiers.i18nStart = { name: 'ɵɵi18nStart', moduleName: CORE$1 };
+        Identifiers.i18nEnd = { name: 'ɵɵi18nEnd', moduleName: CORE$1 };
+        Identifiers.i18nApply = { name: 'ɵɵi18nApply', moduleName: CORE$1 };
+        Identifiers.i18nPostprocess = { name: 'ɵɵi18nPostprocess', moduleName: CORE$1 };
+        Identifiers.i18nLocalize = { name: 'ɵɵi18nLocalize', moduleName: CORE$1 };
+        Identifiers.load = { name: 'ɵɵload', moduleName: CORE$1 };
+        Identifiers.pipe = { name: 'ɵɵpipe', moduleName: CORE$1 };
+        Identifiers.projection = { name: 'ɵɵprojection', moduleName: CORE$1 };
+        Identifiers.projectionDef = { name: 'ɵɵprojectionDef', moduleName: CORE$1 };
+        Identifiers.reference = { name: 'ɵɵreference', moduleName: CORE$1 };
+        Identifiers.inject = { name: 'ɵɵinject', moduleName: CORE$1 };
+        Identifiers.injectAttribute = { name: 'ɵɵinjectAttribute', moduleName: CORE$1 };
+        Identifiers.directiveInject = { name: 'ɵɵdirectiveInject', moduleName: CORE$1 };
+        Identifiers.templateRefExtractor = { name: 'ɵɵtemplateRefExtractor', moduleName: CORE$1 };
+        Identifiers.resolveWindow = { name: 'ɵɵresolveWindow', moduleName: CORE$1 };
+        Identifiers.resolveDocument = { name: 'ɵɵresolveDocument', moduleName: CORE$1 };
+        Identifiers.resolveBody = { name: 'ɵɵresolveBody', moduleName: CORE$1 };
+        Identifiers.defineBase = { name: 'ɵɵdefineBase', moduleName: CORE$1 };
         Identifiers.BaseDef = {
-            name: 'ΔBaseDef',
+            name: 'ɵɵBaseDef',
             moduleName: CORE$1,
         };
-        Identifiers.defineComponent = { name: 'ΔdefineComponent', moduleName: CORE$1 };
-        Identifiers.setComponentScope = { name: 'ΔsetComponentScope', moduleName: CORE$1 };
+        Identifiers.defineComponent = { name: 'ɵɵdefineComponent', moduleName: CORE$1 };
+        Identifiers.setComponentScope = { name: 'ɵɵsetComponentScope', moduleName: CORE$1 };
         Identifiers.ComponentDefWithMeta = {
-            name: 'ΔComponentDefWithMeta',
+            name: 'ɵɵComponentDefWithMeta',
             moduleName: CORE$1,
         };
         Identifiers.defineDirective = {
-            name: 'ΔdefineDirective',
+            name: 'ɵɵdefineDirective',
             moduleName: CORE$1,
         };
         Identifiers.DirectiveDefWithMeta = {
-            name: 'ΔDirectiveDefWithMeta',
+            name: 'ɵɵDirectiveDefWithMeta',
             moduleName: CORE$1,
         };
         Identifiers.InjectorDef = {
-            name: 'ΔInjectorDef',
+            name: 'ɵɵInjectorDef',
             moduleName: CORE$1,
         };
         Identifiers.defineInjector = {
-            name: 'ΔdefineInjector',
+            name: 'ɵɵdefineInjector',
             moduleName: CORE$1,
         };
         Identifiers.NgModuleDefWithMeta = {
-            name: 'ΔNgModuleDefWithMeta',
+            name: 'ɵɵNgModuleDefWithMeta',
             moduleName: CORE$1,
         };
-        Identifiers.defineNgModule = { name: 'ΔdefineNgModule', moduleName: CORE$1 };
-        Identifiers.setNgModuleScope = { name: 'ΔsetNgModuleScope', moduleName: CORE$1 };
-        Identifiers.PipeDefWithMeta = { name: 'ΔPipeDefWithMeta', moduleName: CORE$1 };
-        Identifiers.definePipe = { name: 'ΔdefinePipe', moduleName: CORE$1 };
-        Identifiers.queryRefresh = { name: 'ΔqueryRefresh', moduleName: CORE$1 };
-        Identifiers.viewQuery = { name: 'ΔviewQuery', moduleName: CORE$1 };
-        Identifiers.staticViewQuery = { name: 'ΔstaticViewQuery', moduleName: CORE$1 };
-        Identifiers.staticContentQuery = { name: 'ΔstaticContentQuery', moduleName: CORE$1 };
-        Identifiers.loadViewQuery = { name: 'ΔloadViewQuery', moduleName: CORE$1 };
-        Identifiers.contentQuery = { name: 'ΔcontentQuery', moduleName: CORE$1 };
-        Identifiers.loadContentQuery = { name: 'ΔloadContentQuery', moduleName: CORE$1 };
-        Identifiers.NgOnChangesFeature = { name: 'ΔNgOnChangesFeature', moduleName: CORE$1 };
-        Identifiers.InheritDefinitionFeature = { name: 'ΔInheritDefinitionFeature', moduleName: CORE$1 };
-        Identifiers.ProvidersFeature = { name: 'ΔProvidersFeature', moduleName: CORE$1 };
-        Identifiers.listener = { name: 'Δlistener', moduleName: CORE$1 };
+        Identifiers.defineNgModule = { name: 'ɵɵdefineNgModule', moduleName: CORE$1 };
+        Identifiers.setNgModuleScope = { name: 'ɵɵsetNgModuleScope', moduleName: CORE$1 };
+        Identifiers.PipeDefWithMeta = { name: 'ɵɵPipeDefWithMeta', moduleName: CORE$1 };
+        Identifiers.definePipe = { name: 'ɵɵdefinePipe', moduleName: CORE$1 };
+        Identifiers.queryRefresh = { name: 'ɵɵqueryRefresh', moduleName: CORE$1 };
+        Identifiers.viewQuery = { name: 'ɵɵviewQuery', moduleName: CORE$1 };
+        Identifiers.staticViewQuery = { name: 'ɵɵstaticViewQuery', moduleName: CORE$1 };
+        Identifiers.staticContentQuery = { name: 'ɵɵstaticContentQuery', moduleName: CORE$1 };
+        Identifiers.loadViewQuery = { name: 'ɵɵloadViewQuery', moduleName: CORE$1 };
+        Identifiers.contentQuery = { name: 'ɵɵcontentQuery', moduleName: CORE$1 };
+        Identifiers.loadContentQuery = { name: 'ɵɵloadContentQuery', moduleName: CORE$1 };
+        Identifiers.NgOnChangesFeature = { name: 'ɵɵNgOnChangesFeature', moduleName: CORE$1 };
+        Identifiers.InheritDefinitionFeature = { name: 'ɵɵInheritDefinitionFeature', moduleName: CORE$1 };
+        Identifiers.ProvidersFeature = { name: 'ɵɵProvidersFeature', moduleName: CORE$1 };
+        Identifiers.listener = { name: 'ɵɵlistener', moduleName: CORE$1 };
         Identifiers.getFactoryOf = {
-            name: 'ΔgetFactoryOf',
+            name: 'ɵɵgetFactoryOf',
             moduleName: CORE$1,
         };
         Identifiers.getInheritedFactory = {
-            name: 'ΔgetInheritedFactory',
+            name: 'ɵɵgetInheritedFactory',
             moduleName: CORE$1,
         };
         Identifiers.registerNgModuleType = { name: 'ɵregisterNgModuleType', moduleName: CORE$1 };
         // sanitization-related functions
-        Identifiers.sanitizeHtml = { name: 'ΔsanitizeHtml', moduleName: CORE$1 };
-        Identifiers.sanitizeStyle = { name: 'ΔsanitizeStyle', moduleName: CORE$1 };
-        Identifiers.defaultStyleSanitizer = { name: 'ΔdefaultStyleSanitizer', moduleName: CORE$1 };
-        Identifiers.sanitizeResourceUrl = { name: 'ΔsanitizeResourceUrl', moduleName: CORE$1 };
-        Identifiers.sanitizeScript = { name: 'ΔsanitizeScript', moduleName: CORE$1 };
-        Identifiers.sanitizeUrl = { name: 'ΔsanitizeUrl', moduleName: CORE$1 };
-        Identifiers.sanitizeUrlOrResourceUrl = { name: 'ΔsanitizeUrlOrResourceUrl', moduleName: CORE$1 };
+        Identifiers.sanitizeHtml = { name: 'ɵɵsanitizeHtml', moduleName: CORE$1 };
+        Identifiers.sanitizeStyle = { name: 'ɵɵsanitizeStyle', moduleName: CORE$1 };
+        Identifiers.defaultStyleSanitizer = { name: 'ɵɵdefaultStyleSanitizer', moduleName: CORE$1 };
+        Identifiers.sanitizeResourceUrl = { name: 'ɵɵsanitizeResourceUrl', moduleName: CORE$1 };
+        Identifiers.sanitizeScript = { name: 'ɵɵsanitizeScript', moduleName: CORE$1 };
+        Identifiers.sanitizeUrl = { name: 'ɵɵsanitizeUrl', moduleName: CORE$1 };
+        Identifiers.sanitizeUrlOrResourceUrl = { name: 'ɵɵsanitizeUrlOrResourceUrl', moduleName: CORE$1 };
         return Identifiers;
     }());
 
@@ -5125,7 +5125,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         }
         var token = meta.type;
         var providedIn = meta.providedIn;
-        var expression = importExpr(Identifiers.ΔdefineInjectable).callFn([mapToMapExpression({ token: token, factory: result.factory, providedIn: providedIn })]);
+        var expression = importExpr(Identifiers.ɵɵdefineInjectable).callFn([mapToMapExpression({ token: token, factory: result.factory, providedIn: providedIn })]);
         var type = new ExpressionType(importExpr(Identifiers.InjectableDef, [typeWithParameters(meta.type, meta.typeArgumentCount)]));
         return {
             expression: expression,
@@ -6471,7 +6471,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             definitionMap.bootstrap = refsToArray(bootstrap, containsForwardDecls);
         }
         // If requested to emit scope information inline, pass the declarations, imports and exports to
-        // the `ΔdefineNgModule` call. The JIT compilation uses this.
+        // the `ɵɵdefineNgModule` call. The JIT compilation uses this.
         if (emitInline) {
             if (declarations.length) {
                 definitionMap.declarations = refsToArray(declarations, containsForwardDecls);
@@ -6483,7 +6483,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 definitionMap.exports = refsToArray(exports, containsForwardDecls);
             }
         }
-        // If not emitting inline, the scope information is not passed into `ΔdefineNgModule` as it would
+        // If not emitting inline, the scope information is not passed into `ɵɵdefineNgModule` as it would
         // prevent tree-shaking of the declarations, imports and exports references.
         else {
             var setNgModuleScopeCall = generateSetNgModuleScopeCall(meta);
@@ -6502,7 +6502,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         return { expression: expression, type: type, additionalStatements: additionalStatements };
     }
     /**
-     * Generates a function call to `ΔsetNgModuleScope` with all necessary information so that the
+     * Generates a function call to `ɵɵsetNgModuleScope` with all necessary information so that the
      * transitive module scope can be computed during runtime in JIT mode. This call is marked pure
      * such that the references to declarations, imports and exports may be elided causing these
      * symbols to become tree-shakeable.
@@ -7481,6 +7481,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         var actionStmts = [];
         flattenStatements(actionWithoutBuiltins.visit(visitor, _Mode.Statement), actionStmts);
         prependTemporaryDecls(visitor.temporaryCount, bindingId, actionStmts);
+        if (visitor.usesImplicitReceiver) {
+            localResolver.notifyImplicitReceiverUse();
+        }
         var lastIndex = actionStmts.length - 1;
         var preventDefaultVar = null;
         if (lastIndex >= 0) {
@@ -7528,6 +7531,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         var visitor = new _AstToIrVisitor(localResolver, implicitReceiver, bindingId, interpolationFunction);
         var outputExpr = expressionWithoutBuiltins.visit(visitor, _Mode.Expression);
         var stmts = getStatementsFromVisitor(visitor, bindingId);
+        if (visitor.usesImplicitReceiver) {
+            localResolver.notifyImplicitReceiverUse();
+        }
         if (visitor.temporaryCount === 0 && form == BindingForm.TrySimple) {
             return new ConvertPropertyBindingResult([], outputExpr);
         }
@@ -7553,6 +7559,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     function convertUpdateArguments(localResolver, contextVariableExpression, expressionWithArgumentsToExtract, bindingId) {
         var visitor = new _AstToIrVisitor(localResolver, contextVariableExpression, bindingId, undefined);
         var outputExpr = expressionWithArgumentsToExtract.visit(visitor, _Mode.Expression);
+        if (visitor.usesImplicitReceiver) {
+            localResolver.notifyImplicitReceiverUse();
+        }
         var stmts = getStatementsFromVisitor(visitor, bindingId);
         // Removing the first argument, because it was a length for ViewEngine, not Ivy.
         var args = outputExpr.args.slice(1);
@@ -7652,6 +7661,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             this._resultMap = new Map();
             this._currentTemporary = 0;
             this.temporaryCount = 0;
+            this.usesImplicitReceiver = false;
         }
         _AstToIrVisitor.prototype.visitBinary = function (ast, mode) {
             var op;
@@ -7731,6 +7741,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         };
         _AstToIrVisitor.prototype.visitImplicitReceiver = function (ast, mode) {
             ensureExpressionMode(mode, ast);
+            this.usesImplicitReceiver = true;
             return this._implicitReceiver;
         };
         _AstToIrVisitor.prototype.visitInterpolation = function (ast, mode) {
@@ -7794,11 +7805,15 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             }
             else {
                 var args = this.visitAll(ast.args, _Mode.Expression);
+                var prevUsesImplicitReceiver = this.usesImplicitReceiver;
                 var result = null;
                 var receiver = this._visit(ast.receiver, _Mode.Expression);
                 if (receiver === this._implicitReceiver) {
                     var varExpr = this._getLocal(ast.name);
                     if (varExpr) {
+                        // Restore the previous "usesImplicitReceiver" state since the implicit
+                        // receiver has been replaced with a resolved local expression.
+                        this.usesImplicitReceiver = prevUsesImplicitReceiver;
                         result = varExpr.callFn(args);
                     }
                 }
@@ -7821,9 +7836,15 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             }
             else {
                 var result = null;
+                var prevUsesImplicitReceiver = this.usesImplicitReceiver;
                 var receiver = this._visit(ast.receiver, _Mode.Expression);
                 if (receiver === this._implicitReceiver) {
                     result = this._getLocal(ast.name);
+                    if (result) {
+                        // Restore the previous "usesImplicitReceiver" state since the implicit
+                        // receiver has been replaced with a resolved local expression.
+                        this.usesImplicitReceiver = prevUsesImplicitReceiver;
+                    }
                 }
                 if (result == null) {
                     result = receiver.prop(ast.name);
@@ -7833,6 +7854,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         };
         _AstToIrVisitor.prototype.visitPropertyWrite = function (ast, mode) {
             var receiver = this._visit(ast.receiver, _Mode.Expression);
+            var prevUsesImplicitReceiver = this.usesImplicitReceiver;
             var varExpr = null;
             if (receiver === this._implicitReceiver) {
                 var localExpr = this._getLocal(ast.name);
@@ -7842,6 +7864,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                         // to a 'context.property' value and will be used as the target of the
                         // write expression.
                         varExpr = localExpr;
+                        // Restore the previous "usesImplicitReceiver" state since the implicit
+                        // receiver has been replaced with a resolved local expression.
+                        this.usesImplicitReceiver = prevUsesImplicitReceiver;
                     }
                     else {
                         // Otherwise it's an error.
@@ -7903,7 +7928,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             //      / \    / \
             //     .  c   .   e
             //    / \    / \
-            //   a   b  ,   d
+            //   a   b  .   d
             //         / \
             //        .   c
             //       / \
@@ -8062,6 +8087,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     var DefaultLocalResolver = /** @class */ (function () {
         function DefaultLocalResolver() {
         }
+        DefaultLocalResolver.prototype.notifyImplicitReceiverUse = function () { };
         DefaultLocalResolver.prototype.getLocal = function (name) {
             if (name === EventHandlerVars.event.name) {
                 return EventHandlerVars.event;
@@ -15386,8 +15412,6 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * 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
      */
-    // Default selector used by `<ng-content>` if none specified
-    var DEFAULT_NG_CONTENT_SELECTOR = '*';
     // Selector attribute name of `<ng-content>`
     var NG_CONTENT_SELECT_ATTR$1 = 'select';
     // Attribute name of `ngProjectAs`.
@@ -15399,14 +15423,17 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     function renderFlagCheckIfStmt(flags, statements) {
         return ifStmt(variable(RENDER_FLAGS).bitwiseAnd(literal(flags), null, false), statements);
     }
-    function prepareEventListenerParameters(eventAst, bindingContext, handlerName, scope) {
+    function prepareEventListenerParameters(eventAst, handlerName, scope) {
         if (handlerName === void 0) { handlerName = null; }
         if (scope === void 0) { scope = null; }
         var type = eventAst.type, name = eventAst.name, target = eventAst.target, phase = eventAst.phase, handler = eventAst.handler;
         if (target && !GLOBAL_TARGET_RESOLVERS.has(target)) {
             throw new Error("Unexpected global target '" + target + "' defined for '" + name + "' event.\n        Supported list of global targets: " + Array.from(GLOBAL_TARGET_RESOLVERS.keys()) + ".");
         }
-        var bindingExpr = convertActionBinding(scope, bindingContext, handler, 'b', function () { return error('Unexpected interpolation'); }, eventAst.handlerSpan);
+        var implicitReceiverExpr = (scope === null || scope.bindingLevel === 0) ?
+            variable(CONTEXT_NAME) :
+            scope.getOrCreateSharedContextVar(0);
+        var bindingExpr = convertActionBinding(scope, implicitReceiverExpr, handler, 'b', function () { return error('Unexpected interpolation'); }, eventAst.handlerSpan);
         var statements = [];
         if (scope) {
             statements.push.apply(statements, __spread(scope.restoreViewStatement()));
@@ -15478,13 +15505,16 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             this._pureFunctionSlots = 0;
             // Number of binding slots
             this._bindingSlots = 0;
-            // Whether the template includes <ng-content> tags.
-            this._hasNgContent = false;
-            // Selectors found in the <ng-content> tags in the template.
-            this._ngContentSelectors = [];
+            // Projection slots found in the template. Projection slots can distribute projected
+            // nodes based on a selector, or can just use the wildcard selector to match
+            // all nodes which aren't matching any selector.
+            this._ngContentReservedSlots = [];
             // Number of non-default selectors found in all parent templates of this template. We need to
-            // track it to properly adjust projection bucket index in the `projection` instruction.
+            // track it to properly adjust projection slot index in the `projection` instruction.
             this._ngContentSelectorsOffset = 0;
+            // Expression that should be used as implicit receiver when converting template
+            // expressions to output AST.
+            this._implicitReceiverExpr = null;
             // These should be handled in the template or element directly.
             this.visitReference = invalid$1;
             this.visitVariable = invalid$1;
@@ -15557,15 +15587,17 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             // Nested templates must be processed before creation instructions so template()
             // instructions can be generated with the correct internal const count.
             this._nestedTemplateFns.forEach(function (buildTemplateFn) { return buildTemplateFn(); });
-            // Output the `projectionDef` instruction when some `<ng-content>` are present.
-            // The `projectionDef` instruction only emitted for the component template and it is skipped for
-            // nested templates (<ng-template> tags).
-            if (this.level === 0 && this._hasNgContent) {
+            // Output the `projectionDef` instruction when some `<ng-content>` tags are present.
+            // The `projectionDef` instruction is only emitted for the component template and
+            // is skipped for nested templates (<ng-template> tags).
+            if (this.level === 0 && this._ngContentReservedSlots.length) {
                 var parameters = [];
-                // Only selectors with a non-default value are generated
-                if (this._ngContentSelectors.length) {
-                    var r3Selectors = this._ngContentSelectors.map(function (s) { return parseSelectorToR3Selector(s); });
-                    parameters.push(this.constantPool.getConstLiteral(asLiteral(r3Selectors), true));
+                // By default the `projectionDef` instructions creates one slot for the wildcard
+                // selector if no parameters are passed. Therefore we only want to allocate a new
+                // array for the projection slots if the default projection slot is not sufficient.
+                if (this._ngContentReservedSlots.length > 1 || this._ngContentReservedSlots[0] !== '*') {
+                    var r3ReservedSlots = this._ngContentReservedSlots.map(function (s) { return s !== '*' ? parseSelectorToR3Selector(s) : s; });
+                    parameters.push(this.constantPool.getConstLiteral(asLiteral(r3ReservedSlots), true));
                 }
                 // Since we accumulate ngContent selectors while processing template elements,
                 // we *prepend* `projectionDef` to creation instructions block, to put it before
@@ -15596,6 +15628,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         };
         // LocalResolver
         TemplateDefinitionBuilder.prototype.getLocal = function (name) { return this._bindingScope.get(name); };
+        // LocalResolver
+        TemplateDefinitionBuilder.prototype.notifyImplicitReceiverUse = function () { this._bindingScope.notifyImplicitReceiverUse(); };
         TemplateDefinitionBuilder.prototype.i18nTranslate = function (message, params, ref, transformFn) {
             var _a;
             if (params === void 0) { params = {}; }
@@ -15733,7 +15767,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             var _a = this.i18n, index = _a.index, bindings = _a.bindings;
             if (bindings.size) {
                 bindings.forEach(function (binding) {
-                    _this.updateInstruction(index, span, Identifiers$1.i18nExp, function () { return [_this.convertPropertyBinding(variable(CONTEXT_NAME), binding)]; });
+                    _this.updateInstruction(index, span, Identifiers$1.i18nExp, function () { return [_this.convertPropertyBinding(binding)]; });
                 });
                 this.updateInstruction(index, span, Identifiers$1.i18nApply, [literal(index)]);
             }
@@ -15743,13 +15777,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             this.i18n = null; // reset local i18n context
         };
         TemplateDefinitionBuilder.prototype.visitContent = function (ngContent) {
-            this._hasNgContent = true;
             var slot = this.allocateDataSlot();
-            var selectorIndex = ngContent.selector === DEFAULT_NG_CONTENT_SELECTOR ?
-                0 :
-                this._ngContentSelectors.push(ngContent.selector) + this._ngContentSelectorsOffset;
+            var projectionSlotIdx = this._ngContentSelectorsOffset + this._ngContentReservedSlots.length;
             var parameters = [literal(slot)];
             var attributes = [];
+            this._ngContentReservedSlots.push(ngContent.selector);
             ngContent.attributes.forEach(function (attribute) {
                 var name = attribute.name, value = attribute.value;
                 if (name === NG_PROJECT_AS_ATTR_NAME) {
@@ -15760,10 +15792,10 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 }
             });
             if (attributes.length > 0) {
-                parameters.push(literal(selectorIndex), literalArr(attributes));
+                parameters.push(literal(projectionSlotIdx), literalArr(attributes));
             }
-            else if (selectorIndex !== 0) {
-                parameters.push(literal(selectorIndex));
+            else if (projectionSlotIdx !== 0) {
+                parameters.push(literal(projectionSlotIdx));
             }
             this.creationInstruction(ngContent.sourceSpan, Identifiers$1.projection, parameters);
         };
@@ -15871,7 +15903,6 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             if (currentNamespace !== wasInNamespace) {
                 this.addNamespaceInstruction(currentNamespace, element);
             }
-            var implicit = variable(CONTEXT_NAME);
             if (this.i18n) {
                 this.i18n.appendElement(element.i18n, elementIndex);
             }
@@ -15913,7 +15944,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                                 i18nAttrArgs_1.push(literal(attr.name), _this.i18nTranslate(message, params));
                                 converted.expressions.forEach(function (expression) {
                                     hasBindings_1 = true;
-                                    var binding = _this.convertExpressionBinding(implicit, expression);
+                                    var binding = _this.convertExpressionBinding(expression);
                                     _this.updateInstruction(elementIndex, element.sourceSpan, Identifiers$1.i18nExp, [binding]);
                                 });
                             }
@@ -15934,7 +15965,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 // designed to run inside of `elementStart` and `elementEnd`. The update instructions
                 // (things like `elementStyleProp`, `elementClassProp`, etc..) are applied later on in this
                 // file
-                this.processStylingInstruction(implicit, stylingBuilder.buildElementStylingInstruction(element.sourceSpan, this.constantPool), true);
+                this.processStylingInstruction(stylingBuilder.buildElementStylingInstruction(element.sourceSpan, this.constantPool), true);
                 // Generate Listeners (outputs)
                 element.outputs.forEach(function (outputAst) {
                     _this.creationInstruction(outputAst.sourceSpan, Identifiers$1.listener, _this.prepareListenerParameter(element.name, outputAst, elementIndex));
@@ -15951,7 +15982,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             // and assign in the code below.
             stylingBuilder.buildUpdateLevelInstructions(this._valueConverter).forEach(function (instruction) {
                 _this._bindingSlots += instruction.allocateBindingSlots;
-                _this.processStylingInstruction(implicit, instruction, false);
+                _this.processStylingInstruction(instruction, false);
             });
             // the reason why `undefined` is used is because the renderer understands this as a
             // special value to symbolize that there is no RHS to this binding
@@ -15977,7 +16008,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                     _this.updateInstruction(elementIndex, input.sourceSpan, Identifiers$1.property, function () {
                         return [
                             literal(bindingName_1),
-                            (hasValue_1 ? _this.convertPropertyBinding(implicit, value_1, /* skipBindFn */ true) :
+                            (hasValue_1 ? _this.convertPropertyBinding(value_1, /* skipBindFn */ true) :
                                 emptyValueBindInstruction),
                         ];
                     });
@@ -16010,15 +16041,13 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                         if (inputType === 0 /* Property */) {
                             if (value_2 instanceof Interpolation) {
                                 _this.updateInstruction(elementIndex, input.sourceSpan, getPropertyInterpolationExpression(value_2), function () {
-                                    return __spread([literal(attrName_1)], _this.getUpdateInstructionArguments(variable(CONTEXT_NAME), value_2), params_2);
+                                    return __spread([literal(attrName_1)], _this.getUpdateInstructionArguments(value_2), params_2);
                                 });
                             }
                             else {
                                 // Bound, un-interpolated properties
                                 _this.updateInstruction(elementIndex, input.sourceSpan, Identifiers$1.property, function () {
-                                    return __spread([
-                                        literal(attrName_1), _this.convertPropertyBinding(implicit, value_2, true)
-                                    ], params_2);
+                                    return __spread([literal(attrName_1), _this.convertPropertyBinding(value_2, true)], params_2);
                                 });
                             }
                         }
@@ -16032,8 +16061,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                             }
                             _this.updateInstruction(elementIndex, input.sourceSpan, instruction_1, function () {
                                 return __spread([
-                                    literal(elementIndex), literal(attrName_1),
-                                    _this.convertPropertyBinding(implicit, value_2)
+                                    literal(elementIndex), literal(attrName_1), _this.convertPropertyBinding(value_2)
                                 ], params_2);
                             });
                         }
@@ -16094,11 +16122,10 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             // template definition. e.g. <div *ngIf="showing">{{ foo }}</div>  <div #foo></div>
             this._nestedTemplateFns.push(function () {
                 var _a;
-                var templateFunctionExpr = templateVisitor.buildTemplateFunction(template.children, template.variables, _this._ngContentSelectors.length + _this._ngContentSelectorsOffset, template.i18n);
+                var templateFunctionExpr = templateVisitor.buildTemplateFunction(template.children, template.variables, _this._ngContentReservedSlots.length + _this._ngContentSelectorsOffset, template.i18n);
                 _this.constantPool.statements.push(templateFunctionExpr.toDeclStmt(templateName, null));
-                if (templateVisitor._hasNgContent) {
-                    _this._hasNgContent = true;
-                    (_a = _this._ngContentSelectors).push.apply(_a, __spread(templateVisitor._ngContentSelectors));
+                if (templateVisitor._ngContentReservedSlots.length) {
+                    (_a = _this._ngContentReservedSlots).push.apply(_a, __spread(templateVisitor._ngContentReservedSlots));
                 }
             });
             // e.g. template(1, MyComp_Template_1)
@@ -16106,13 +16133,12 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 parameters.splice(2, 0, literal(templateVisitor.getConstCount()), literal(templateVisitor.getVarCount()));
                 return trimTrailingNulls(parameters);
             });
-            // handle property bindings e.g. Δproperty('ngForOf', ctx.items), et al;
-            var context = variable(CONTEXT_NAME);
-            this.templatePropertyBindings(template, templateIndex, context, template.templateAttrs);
+            // handle property bindings e.g. ɵɵproperty('ngForOf', ctx.items), et al;
+            this.templatePropertyBindings(template, templateIndex, template.templateAttrs);
             // Only add normal input/output binding instructions on explicit ng-template elements.
             if (template.tagName === NG_TEMPLATE_TAG_NAME) {
                 // Add the input bindings
-                this.templatePropertyBindings(template, templateIndex, context, template.inputs);
+                this.templatePropertyBindings(template, templateIndex, template.inputs);
                 // Generate listeners for directive output
                 template.outputs.forEach(function (outputAst) {
                     _this.creationInstruction(outputAst.sourceSpan, Identifiers$1.listener, _this.prepareListenerParameter('ng_template', outputAst, templateIndex));
@@ -16134,7 +16160,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             this.creationInstruction(text.sourceSpan, Identifiers$1.text, [literal(nodeIndex)]);
             var value = text.value.visit(this._valueConverter);
             this.allocateBindingSlots(value);
-            this.updateInstruction(nodeIndex, text.sourceSpan, Identifiers$1.textBinding, function () { return [literal(nodeIndex), _this.convertPropertyBinding(variable(CONTEXT_NAME), value)]; });
+            this.updateInstruction(nodeIndex, text.sourceSpan, Identifiers$1.textBinding, function () { return [literal(nodeIndex), _this.convertPropertyBinding(value)]; });
         };
         TemplateDefinitionBuilder.prototype.visitText = function (text) {
             // when a text element is located within a translatable
@@ -16181,18 +16207,18 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         TemplateDefinitionBuilder.prototype.getConstCount = function () { return this._dataIndex; };
         TemplateDefinitionBuilder.prototype.getVarCount = function () { return this._pureFunctionSlots; };
         TemplateDefinitionBuilder.prototype.getNgContentSelectors = function () {
-            return this._hasNgContent ?
-                this.constantPool.getConstLiteral(asLiteral(this._ngContentSelectors), true) :
+            return this._ngContentReservedSlots.length ?
+                this.constantPool.getConstLiteral(asLiteral(this._ngContentReservedSlots), true) :
                 null;
         };
         TemplateDefinitionBuilder.prototype.bindingContext = function () { return "" + this._bindingContext++; };
-        TemplateDefinitionBuilder.prototype.templatePropertyBindings = function (template, templateIndex, context, attrs) {
+        TemplateDefinitionBuilder.prototype.templatePropertyBindings = function (template, templateIndex, attrs) {
             var _this = this;
             attrs.forEach(function (input) {
                 if (input instanceof BoundAttribute) {
                     var value_4 = input.value.visit(_this._valueConverter);
                     _this.allocateBindingSlots(value_4);
-                    _this.updateInstruction(templateIndex, template.sourceSpan, Identifiers$1.property, function () { return [literal(input.name), _this.convertPropertyBinding(context, value_4, true)]; });
+                    _this.updateInstruction(templateIndex, template.sourceSpan, Identifiers$1.property, function () { return [literal(input.name), _this.convertPropertyBinding(value_4, true)]; });
                 }
             });
         };
@@ -16207,11 +16233,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 return instruction(span, reference, params).toStmt();
             });
         };
-        TemplateDefinitionBuilder.prototype.processStylingInstruction = function (implicit, instruction, createMode) {
+        TemplateDefinitionBuilder.prototype.processStylingInstruction = function (instruction, createMode) {
             var _this = this;
             if (instruction) {
                 var paramsFn = function () {
-                    return instruction.buildParams(function (value) { return _this.convertPropertyBinding(implicit, value, true); });
+                    return instruction.buildParams(function (value) { return _this.convertPropertyBinding(value, true); });
                 };
                 if (createMode) {
                     this.creationInstruction(instruction.sourceSpan, instruction.reference, paramsFn);
@@ -16239,17 +16265,29 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         TemplateDefinitionBuilder.prototype.allocateBindingSlots = function (value) {
             this._bindingSlots += value instanceof Interpolation ? value.expressions.length : 1;
         };
-        TemplateDefinitionBuilder.prototype.convertExpressionBinding = function (implicit, value) {
-            var convertedPropertyBinding = convertPropertyBinding(this, implicit, value, this.bindingContext(), BindingForm.TrySimple);
+        /**
+         * Gets an expression that refers to the implicit receiver. The implicit
+         * receiver is always the root level context.
+         */
+        TemplateDefinitionBuilder.prototype.getImplicitReceiverExpr = function () {
+            if (this._implicitReceiverExpr) {
+                return this._implicitReceiverExpr;
+            }
+            return this._implicitReceiverExpr = this.level === 0 ?
+                variable(CONTEXT_NAME) :
+                this._bindingScope.getOrCreateSharedContextVar(0);
+        };
+        TemplateDefinitionBuilder.prototype.convertExpressionBinding = function (value) {
+            var convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext(), BindingForm.TrySimple);
             var valExpr = convertedPropertyBinding.currValExpr;
             return importExpr(Identifiers$1.bind).callFn([valExpr]);
         };
-        TemplateDefinitionBuilder.prototype.convertPropertyBinding = function (implicit, value, skipBindFn) {
+        TemplateDefinitionBuilder.prototype.convertPropertyBinding = function (value, skipBindFn) {
             var _a;
             var interpolationFn = value instanceof Interpolation ? interpolate : function () { return error('Unexpected interpolation'); };
-            var convertedPropertyBinding = convertPropertyBinding(this, implicit, value, this.bindingContext(), BindingForm.TrySimple, interpolationFn);
-            (_a = this._tempVariables).push.apply(_a, __spread(convertedPropertyBinding.stmts));
+            var convertedPropertyBinding = convertPropertyBinding(this, this.getImplicitReceiverExpr(), value, this.bindingContext(), BindingForm.TrySimple, interpolationFn);
             var valExpr = convertedPropertyBinding.currValExpr;
+            (_a = this._tempVariables).push.apply(_a, __spread(convertedPropertyBinding.stmts));
             return value instanceof Interpolation || skipBindFn ? valExpr :
                 importExpr(Identifiers$1.bind).callFn([valExpr]);
         };
@@ -16257,12 +16295,11 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
          * Gets a list of argument expressions to pass to an update instruction expression. Also updates
          * the temp variables state with temp variables that were identified as needing to be created
          * while visiting the arguments.
-         * @param contextExpression The expression for the context variable used to create arguments
          * @param value The original expression we will be resolving an arguments list from.
          */
-        TemplateDefinitionBuilder.prototype.getUpdateInstructionArguments = function (contextExpression, value) {
+        TemplateDefinitionBuilder.prototype.getUpdateInstructionArguments = function (value) {
             var _a;
-            var _b = convertUpdateArguments(this, contextExpression, value, this.bindingContext()), args = _b.args, stmts = _b.stmts;
+            var _b = convertUpdateArguments(this, this.getImplicitReceiverExpr(), value, this.bindingContext()), args = _b.args, stmts = _b.stmts;
             (_a = this._tempVariables).push.apply(_a, __spread(stmts));
             return args;
         };
@@ -16381,8 +16418,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                     sanitizeIdentifier(eventName);
                 var handlerName = _this.templateName + "_" + tagName + "_" + bindingFnName + "_" + index + "_listener";
                 var scope = _this._bindingScope.nestedScope(_this._bindingScope.bindingLevel);
-                var context = variable(CONTEXT_NAME);
-                return prepareEventListenerParameters(outputAst, context, handlerName, scope);
+                return prepareEventListenerParameters(outputAst, handlerName, scope);
             };
         };
         return TemplateDefinitionBuilder;
@@ -16602,13 +16638,35 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             });
             return this;
         };
+        // Implemented as part of LocalResolver.
         BindingScope.prototype.getLocal = function (name) { return this.get(name); };
+        // Implemented as part of LocalResolver.
+        BindingScope.prototype.notifyImplicitReceiverUse = function () {
+            if (this.bindingLevel !== 0) {
+                // Since the implicit receiver is accessed in an embedded view, we need to
+                // ensure that we declare a shared context variable for the current template
+                // in the update variables.
+                this.map.get(SHARED_CONTEXT_KEY + 0).declare = true;
+            }
+        };
         BindingScope.prototype.nestedScope = function (level) {
             var newScope = new BindingScope(level, this);
             if (level > 0)
                 newScope.generateSharedContextVar(0);
             return newScope;
         };
+        /**
+         * Gets or creates a shared context variable and returns its expression. Note that
+         * this does not mean that the shared variable will be declared. Variables in the
+         * binding scope will be only declared if they are used.
+         */
+        BindingScope.prototype.getOrCreateSharedContextVar = function (retrievalLevel) {
+            var bindingKey = SHARED_CONTEXT_KEY + retrievalLevel;
+            if (!this.map.has(bindingKey)) {
+                this.generateSharedContextVar(retrievalLevel);
+            }
+            return this.map.get(bindingKey).lhs;
+        };
         BindingScope.prototype.getSharedContextName = function (retrievalLevel) {
             var sharedCtxObj = this.map.get(SHARED_CONTEXT_KEY + retrievalLevel);
             return sharedCtxObj && sharedCtxObj.declare ? sharedCtxObj.lhs : null;
@@ -17255,7 +17313,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         // Calculate host event bindings
         var eventBindings = bindingParser.createDirectiveHostEventAsts(directiveSummary, hostBindingSourceSpan);
         if (eventBindings && eventBindings.length) {
-            var listeners = createHostListeners(bindingContext, eventBindings, meta);
+            var listeners = createHostListeners(eventBindings, meta);
             createStatements.push.apply(createStatements, __spread(listeners));
         }
         // Calculate the host property bindings
@@ -17391,14 +17449,14 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         }
         return { bindingName: bindingName, instruction: instruction, isAttribute: !!attrMatches };
     }
-    function createHostListeners(bindingContext, eventBindings, meta) {
+    function createHostListeners(eventBindings, meta) {
         return eventBindings.map(function (binding) {
             var bindingName = binding.name && sanitizeIdentifier(binding.name);
             var bindingFnName = binding.type === 1 /* Animation */ ?
                 prepareSyntheticListenerFunctionName(bindingName, binding.targetOrPhase) :
                 bindingName;
             var handlerName = meta.name && bindingName ? meta.name + "_" + bindingFnName + "_HostBindingHandler" : null;
-            var params = prepareEventListenerParameters(BoundEvent.fromParsedEvent(binding), bindingContext, handlerName);
+            var params = prepareEventListenerParameters(BoundEvent.fromParsedEvent(binding), handlerName);
             var instruction = binding.type == 1 /* Animation */ ? Identifiers$1.componentHostSyntheticListener : Identifiers$1.listener;
             return importExpr(instruction).callFn(params).toStmt();
         });
@@ -17775,7 +17833,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * 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$1 = new Version('8.0.0-rc.4');
+    var VERSION$1 = new Version('8.0.2');
 
     /**
      * @license
@@ -29398,7 +29456,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      *
      * @codeGenApi
      */
-    function ΔdefineInjectable(opts) {
+    function ɵɵdefineInjectable(opts) {
         return {
             providedIn: opts.providedIn || null, factory: opts.factory, value: undefined,
         };
@@ -29423,7 +29481,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      *
      * @publicApi
      */
-    function ΔdefineInjector(options) {
+    function ɵɵdefineInjector(options) {
         return {
             factory: options.factory, providers: options.providers || [], imports: options.imports || [],
         };
@@ -29617,7 +29675,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             return _currentInjector.get(token, flags & InjectFlags.Optional ? null : undefined, flags);
         }
     }
-    function Δinject(token, flags) {
+    function ɵɵinject(token, flags) {
         if (flags === void 0) { flags = InjectFlags.Default; }
         return (_injectImplementation || injectInjectorOnly)(token, flags);
     }
@@ -29668,10 +29726,10 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                         type = meta;
                     }
                 }
-                args.push(Δinject(type, flags));
+                args.push(ɵɵinject(type, flags));
             }
             else {
-                args.push(Δinject(arg));
+                args.push(ɵɵinject(arg));
             }
         }
         return args;
@@ -29989,7 +30047,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         }
         else if (provider.useExisting) {
             var existingProvider_1 = provider;
-            return function () { return Δinject(existingProvider_1.useExisting); };
+            return function () { return ɵɵinject(existingProvider_1.useExisting); };
         }
         else if (provider.useFactory) {
             var factoryProvider_1 = provider;
@@ -30037,7 +30095,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      */
     function render2CompileInjectable(injectableType, options) {
         if (options && options.providedIn !== undefined && !getInjectableDef(injectableType)) {
-            injectableType.ngInjectableDef = ΔdefineInjectable({
+            injectableType.ngInjectableDef = ɵɵdefineInjectable({
                 providedIn: options.providedIn,
                 factory: convertInjectableProviderToFactory(injectableType, options),
             });
@@ -30106,7 +30164,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 this.__NG_ELEMENT_ID__ = options;
             }
             else if (options !== undefined) {
-                this.ngInjectableDef = ΔdefineInjectable({
+                this.ngInjectableDef = ɵɵdefineInjectable({
                     providedIn: options.providedIn || 'root',
                     factory: options.factory,
                 });
@@ -30192,9 +30250,9 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         Injector.THROW_IF_NOT_FOUND = _THROW_IF_NOT_FOUND;
         Injector.NULL = new NullInjector();
         /** @nocollapse */
-        Injector.ngInjectableDef = ΔdefineInjectable({
+        Injector.ngInjectableDef = ɵɵdefineInjectable({
             providedIn: 'any',
-            factory: function () { return Δinject(INJECTOR); },
+            factory: function () { return ɵɵinject(INJECTOR); },
         });
         /**
          * @internal
@@ -32595,7 +32653,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      *
      * @codeGenApi
      */
-    function ΔnamespaceHTML() {
+    function ɵɵnamespaceHTML() {
         _currentNamespace = null;
     }
     function getNamespace() {
@@ -34851,7 +34909,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
         }
     }
     function executeTemplate(templateFn, rf, context) {
-        ΔnamespaceHTML();
+        ɵɵnamespaceHTML();
         try {
             templateFn(rf, context);
         }
@@ -36819,7 +36877,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
                 factory = function () { return resolveForwardRef$1(provider.useValue); };
             }
             else if (isExistingProvider(provider)) {
-                factory = function () { return Δinject(resolveForwardRef$1(provider.useExisting)); };
+                factory = function () { return ɵɵinject(resolveForwardRef$1(provider.useExisting)); };
             }
             else if (isFactoryProvider(provider)) {
                 factory = function () { return provider.useFactory.apply(provider, __spread(injectArgs(provider.deps || []))); };
@@ -37462,7 +37520,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     /**
      * @publicApi
      */
-    var VERSION$2 = new Version$1('8.0.0-rc.4');
+    var VERSION$2 = new Version$1('8.0.2');
 
     /**
      * @license
@@ -38463,7 +38521,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             }
         };
         /** @nocollapse */
-        IterableDiffers.ngInjectableDef = ΔdefineInjectable({
+        IterableDiffers.ngInjectableDef = ɵɵdefineInjectable({
             providedIn: 'root',
             factory: function () { return new IterableDiffers([new DefaultIterableDifferFactory()]); }
         });
@@ -38539,7 +38597,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             throw new Error("Cannot find a differ supporting object '" + kv + "'");
         };
         /** @nocollapse */
-        KeyValueDiffers.ngInjectableDef = ΔdefineInjectable({
+        KeyValueDiffers.ngInjectableDef = ɵɵdefineInjectable({
             providedIn: 'root',
             factory: function () { return new KeyValueDiffers([new DefaultKeyValueDifferFactory()]); }
         });
@@ -40326,7 +40384,7 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
     /**
      * Default {@link RootContext} for all components rendered with {@link renderComponent}.
      */
-    var ROOT_CONTEXT = new InjectionToken('ROOT_CONTEXT_TOKEN', { providedIn: 'root', factory: function () { return createRootContext(Δinject(SCHEDULER)); } });
+    var ROOT_CONTEXT = new InjectionToken('ROOT_CONTEXT_TOKEN', { providedIn: 'root', factory: function () { return createRootContext(ɵɵinject(SCHEDULER)); } });
     /**
      * A change detection scheduler token for {@link RootContext}. This token is the default value used
      * for the default `RootContext` found in the {@link ROOT_CONTEXT} token.
@@ -40367,10 +40425,8 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
             _this.ngModule = ngModule;
             _this.componentType = componentDef.type;
             _this.selector = componentDef.selectors[0][0];
-            // The component definition does not include the wildcard ('*') selector in its list.
-            // It is implicitly expected as the first item in the projectable nodes array.
             _this.ngContentSelectors =
-                componentDef.ngContentSelectors ? __spread(['*'], componentDef.ngContentSelectors) : [];
+                componentDef.ngContentSelectors ? componentDef.ngContentSelectors : [];
             _this.isBoundToModule = !!ngModule;
             return _this;
         }
@@ -40520,28 +40576,27 @@ define(['exports', 'path', 'typescript', 'fs'], function (exports, path, ts, fs)
      * found in the LICENSE file at https://angular.io/license
      */
     /**
-     * Flattens an array in non-recursive way. Input arrays are not modified.
+     * Flattens an array.
      */
-    function flatten$2(list, mapFn) {
-        var result = [];
-        var i = 0;
-        while (i < list.length) {
+    function flatten$2(list, dst) {
+        if (dst === undefined)
+            dst = list;
+        for (var i = 0; i < list.length; i++) {
             var item = list[i];
             if (Array.isArray(item)) {
-                if (item.length > 0) {
-                    list = item.concat(list.slice(i + 1));
-                    i = 0;
-                }
-                else {
-                    i++;
+                // we need to inline it.
+                if (dst === list) {
+                    // Our assumption that the list was already flat was wrong and
+                    // we need to clone flat since we need to write to it.
+                    dst = list.slice(0, i);
                 }
+                flatten$2(item, dst);
             }
-            else {
-                result.push(mapFn ? mapFn(item) : item);
-                i++;
+            else if (dst !== list) {
+                dst.push(item);
             }
         }
-        return result;
+        return dst;
     }
 
     /**
@@ -42706,7 +42761,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
         if (metadata && metadata.exports) {
             imports = __spread(imports, [metadata.exports]);
         }
-        moduleType.ngInjectorDef = ΔdefineInjector({
+        moduleType.ngInjectorDef = ɵɵdefineInjector({
             factory: convertInjectableProviderToFactory(moduleType, { useClass: moduleType }),
             providers: metadata && metadata.providers,
             imports: imports,
@@ -43064,6 +43119,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
      * an exception is expected during normal execution while profiling.
      *
      * @publicApi
+     * @deprecated the Web Tracing Framework is no longer supported in Angular
      */
     var wtfCreateScope = wtfEnabled ? createScope : function (signature, flags) { return noopScope; };
     /**
@@ -43074,6 +43130,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
      *
      * Returns the `returnValue for easy chaining.
      * @publicApi
+     * @deprecated the Web Tracing Framework is no longer supported in Angular
      */
     var wtfLeave = wtfEnabled ? leave : function (s, r) { return r; };
 
@@ -47955,39 +48012,29 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
         };
         proxy.getQuickInfoAtPosition = function (fileName, position) {
             var base = oldLS.getQuickInfoAtPosition(fileName, position);
-            // TODO(vicb): the tags property has been removed in TS 2.2
-            tryOperation('get quick info', function () {
-                var e_2, _a;
-                var ours = ls.getHoverAt(fileName, position);
-                if (ours) {
-                    var displayParts = [];
-                    try {
-                        for (var _b = __values(ours.text), _c = _b.next(); !_c.done; _c = _b.next()) {
-                            var part = _c.value;
-                            displayParts.push({ kind: part.language || 'angular', text: part.text });
-                        }
-                    }
-                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                    finally {
-                        try {
-                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                        }
-                        finally { if (e_2) throw e_2.error; }
-                    }
-                    var tags = base && base.tags;
-                    base = {
-                        displayParts: displayParts,
-                        documentation: [],
-                        kind: 'angular',
-                        kindModifiers: 'what does this do?',
-                        textSpan: { start: ours.span.start, length: ours.span.end - ours.span.start },
+            var ours = ls.getHoverAt(fileName, position);
+            if (!ours) {
+                return base;
+            }
+            var result = {
+                kind: ts.ScriptElementKind.unknown,
+                kindModifiers: ts.ScriptElementKindModifier.none,
+                textSpan: {
+                    start: ours.span.start,
+                    length: ours.span.end - ours.span.start,
+                },
+                displayParts: ours.text.map(function (part) {
+                    return {
+                        text: part.text,
+                        kind: part.language || 'angular',
                     };
-                    if (tags) {
-                        base.tags = tags;
-                    }
-                }
-            });
-            return base;
+                }),
+                documentation: [],
+            };
+            if (base && base.tags) {
+                result.tags = base.tags;
+            }
+            return result;
         };
         proxy.getSemanticDiagnostics = function (fileName) {
             var result = oldLS.getSemanticDiagnostics(fileName);
@@ -48010,7 +48057,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
                 return base;
             }
             return tryOperation('get definition', function () {
-                var e_3, _a;
+                var e_2, _a;
                 var ours = ls.getDefinitionAt(fileName, position);
                 var combined;
                 if (ours && ours.length) {
@@ -48029,12 +48076,12 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
                             });
                         }
                     }
-                    catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
                     finally {
                         try {
                             if (ours_1_1 && !ours_1_1.done && (_a = ours_1.return)) _a.call(ours_1);
                         }
-                        finally { if (e_3) throw e_3.error; }
+                        finally { if (e_2) throw e_2.error; }
                     }
                 }
                 else {
@@ -48053,7 +48100,7 @@ ${errors.map((err, i) => `${i + 1}) ${err.toString()}`).join('\n  ')}` : '';
      * 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('8.0.0-rc.4');
+    var VERSION$3 = new Version$1('8.0.2');
 
     /**
      * @license