@angular-wave/angular.ts 0.0.72 → 0.1.0

package/src/core/compile/compile.js

@@ -733,13 +733,13 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
        * functions return values - the linking functions - are combined into a composite linking
        * function, which is the a linking function for the node.
        *
-       * @param {NodeList} nodeList an array of nodes or NodeList to compile
+       * @param {NodeList|JQLite} nodeList an array of nodes or NodeList to compile
        * @param {*} transcludeFn A linking function, where the
        *        scope argument is auto-generated to the new child of the transcluded parent scope.
-       * @param {Element=} $rootElement If the nodeList is the root of the compilation tree then
+       * @param {JQLite} [$rootElement] If the nodeList is the root of the compilation tree then
        *        the rootElement must be set the JQLite collection of the compile root. This is
        *        needed so that the JQLite collection items can be replaced with widgets.
-       * @param {number=} maxPriority Max directive priority.
+       * @param {number=} [maxPriority] Max directive priority.
        * @param {*} [ignoreDirective]
        * @param {*} [previousCompileContext]
        * @returns {Function} A composite linking function of all of the matched directives or null.
@@ -755,6 +755,9 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         const linkFns = [];
         let attrs;
         let directives;
+        /**
+         * @type {any}
+         */
         var nodeLinkFn;
         let childNodes;
         let childLinkFn;
@@ -947,8 +950,9 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
        * @param {Element} node Node to search.
        * @param directives An array to which the directives are added to. This array is sorted before
        *        the function returns.
-       * @param {Attributes} attrs The shared attrs object which is used to populate the normalized attributes.
+       * @param {Attributes|import("./attributes").AttributeLike} attrs The shared attrs object which is used to populate the normalized attributes.
        * @param {number=} maxPriority Max directive priority.
+       * @param {boolean=} ignoreDirective
        */
       function collectDirectives(
         node,
@@ -987,7 +991,10 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
               j < jj;
               j++
             ) {
+              /** @type {string|boolean} */
               let attrStartName = false;
+
+              /** @type {string|boolean} */
               let attrEndName = false;
 
               let isNgAttr = false;
@@ -1243,12 +1250,288 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         let directiveName;
         let $template;
         let replaceDirective = originalReplaceDirective;
+        /** @type {any} */
         let childTranscludeFn = transcludeFn;
         let linkFn;
         let didScanForMultipleTransclusion = false;
         let mightHaveMultipleTransclusionError = false;
         let directiveValue;
 
+        /** @type {any} */
+        let nodeLinkFn = function (
+          childLinkFn,
+          scope,
+          linkNode,
+          $rootElement,
+          boundTranscludeFn,
+        ) {
+          let i;
+          let ii;
+          /** @type {import("../../types").Directive|any} */
+          let linkFn;
+          let isolateScope;
+          let controllerScope;
+          let elementControllers;
+          /** @type {import("../../types").TranscludeFunctionObject|any} */
+          let transcludeFn;
+          let $element;
+          let attrs;
+          let scopeBindingInfo;
+
+          if (compileNode === linkNode) {
+            attrs = templateAttrs;
+            $element = templateAttrs.$$element;
+          } else {
+            $element = JQLite(linkNode);
+            attrs = new Attributes(
+              $rootScope,
+              $animate,
+              $exceptionHandler,
+              $sce,
+              $element,
+              templateAttrs,
+            );
+          }
+
+          controllerScope = scope;
+          if (newIsolateScopeDirective) {
+            isolateScope = scope.$new(true);
+          } else if (newScopeDirective) {
+            controllerScope = scope.$parent;
+          }
+
+          if (boundTranscludeFn) {
+            // track `boundTranscludeFn` so it can be unwrapped if `transcludeFn`
+            // is later passed as `parentBoundTranscludeFn` to `publicLinkFn`
+            transcludeFn = controllersBoundTransclude;
+            transcludeFn.$$boundTransclude = boundTranscludeFn;
+            // expose the slots on the `$transclude` function
+            transcludeFn.isSlotFilled = function (slotName) {
+              return !!boundTranscludeFn.$$slots[slotName];
+            };
+          }
+
+          if (controllerDirectives) {
+            elementControllers = setupControllers(
+              $element,
+              attrs,
+              transcludeFn,
+              controllerDirectives,
+              isolateScope,
+              scope,
+              newIsolateScopeDirective,
+            );
+          }
+
+          if (newIsolateScopeDirective) {
+            isolateScope.$$isolateBindings =
+              newIsolateScopeDirective.$$isolateBindings;
+            scopeBindingInfo = initializeDirectiveBindings(
+              scope,
+              attrs,
+              isolateScope,
+              isolateScope.$$isolateBindings,
+              newIsolateScopeDirective,
+            );
+            if (scopeBindingInfo.removeWatches) {
+              isolateScope.$on("$destroy", scopeBindingInfo.removeWatches);
+            }
+          }
+
+          // Initialize bindToController bindings
+          for (const name in elementControllers) {
+            const controllerDirective = controllerDirectives[name];
+            const controller = elementControllers[name];
+            const bindings = controllerDirective.$$bindings.bindToController;
+
+            controller.instance = controller();
+            $element.data(
+              `$${controllerDirective.name}Controller`,
+              controller.instance,
+            );
+            controller.bindingInfo = initializeDirectiveBindings(
+              controllerScope,
+              attrs,
+              controller.instance,
+              bindings,
+              controllerDirective,
+            );
+          }
+
+          // Bind the required controllers to the controller, if `require` is an object and `bindToController` is truthy
+          forEach(controllerDirectives, (controllerDirective, name) => {
+            const { require } = controllerDirective;
+            if (
+              controllerDirective.bindToController &&
+              !Array.isArray(require) &&
+              isObject(require)
+            ) {
+              extend(
+                elementControllers[name].instance,
+                getControllers(name, require, $element, elementControllers),
+              );
+            }
+          });
+
+          // Handle the init and destroy lifecycle hooks on all controllers that have them
+          forEach(elementControllers, (controller) => {
+            const controllerInstance = controller.instance;
+            if (isFunction(controllerInstance.$onChanges)) {
+              try {
+                controllerInstance.$onChanges(
+                  controller.bindingInfo.initialChanges,
+                );
+              } catch (e) {
+                $exceptionHandler(e);
+              }
+            }
+            if (isFunction(controllerInstance.$onInit)) {
+              try {
+                controllerInstance.$onInit();
+              } catch (e) {
+                $exceptionHandler(e);
+              }
+            }
+            if (isFunction(controllerInstance.$doCheck)) {
+              controllerScope.$watch(() => {
+                controllerInstance.$doCheck();
+              });
+              controllerInstance.$doCheck();
+            }
+            if (isFunction(controllerInstance.$onDestroy)) {
+              controllerScope.$on("$destroy", () => {
+                controllerInstance.$onDestroy();
+              });
+            }
+          });
+
+          // PRELINKING
+          for (i = 0, ii = preLinkFns.length; i < ii; i++) {
+            linkFn = preLinkFns[i];
+            invokeLinkFn(
+              linkFn,
+              linkFn.isolateScope ? isolateScope : scope,
+              $element,
+              attrs,
+              linkFn.require &&
+                getControllers(
+                  linkFn.directiveName,
+                  linkFn.require,
+                  $element,
+                  elementControllers,
+                ),
+              transcludeFn,
+            );
+          }
+
+          // RECURSION
+          // We only pass the isolate scope, if the isolate directive has a template,
+          // otherwise the child elements do not belong to the isolate directive.
+          var scopeToChild = scope;
+          if (
+            newIsolateScopeDirective &&
+            (newIsolateScopeDirective.template ||
+              newIsolateScopeDirective.templateUrl === null)
+          ) {
+            scopeToChild = isolateScope;
+          }
+          if (childLinkFn) {
+            childLinkFn(
+              scopeToChild,
+              linkNode.childNodes,
+              undefined,
+              boundTranscludeFn,
+            );
+          }
+
+          // POSTLINKING
+          for (i = postLinkFns.length - 1; i >= 0; i--) {
+            linkFn = postLinkFns[i];
+            invokeLinkFn(
+              linkFn,
+              linkFn.isolateScope ? isolateScope : scope,
+              $element,
+              attrs,
+              linkFn.require &&
+                getControllers(
+                  linkFn.directiveName,
+                  linkFn.require,
+                  $element,
+                  elementControllers,
+                ),
+              transcludeFn,
+            );
+          }
+
+          // Trigger $postLink lifecycle hooks
+          forEach(elementControllers, (controller) => {
+            const controllerInstance = controller.instance;
+            if (isFunction(controllerInstance.$postLink)) {
+              controllerInstance.$postLink();
+            }
+          });
+
+          // This is the function that is injected as `$transclude`.
+          // Note: all arguments are optional!
+          function controllersBoundTransclude(
+            scope,
+            cloneAttachFn,
+            futureParentElement,
+            slotName,
+          ) {
+            let transcludeControllers;
+            // No scope passed in:
+            if (!isScope(scope)) {
+              slotName = futureParentElement;
+              futureParentElement = cloneAttachFn;
+              cloneAttachFn = scope;
+              scope = undefined;
+            }
+
+            if (hasElementTranscludeDirective) {
+              transcludeControllers = elementControllers;
+            }
+            if (!futureParentElement) {
+              futureParentElement = hasElementTranscludeDirective
+                ? $element.parent()
+                : $element;
+            }
+            if (slotName) {
+              // slotTranscludeFn can be one of three things:
+              //  * a transclude function - a filled slot
+              //  * `null` - an optional slot that was not filled
+              //  * `undefined` - a slot that was not declared (i.e. invalid)
+              const slotTranscludeFn = boundTranscludeFn.$$slots[slotName];
+              if (slotTranscludeFn) {
+                return slotTranscludeFn(
+                  scope,
+                  cloneAttachFn,
+                  transcludeControllers,
+                  futureParentElement,
+                  scopeToChild,
+                );
+              }
+              if (isUndefined(slotTranscludeFn)) {
+                throw $compileMinErr(
+                  "noslot",
+                  'No parent directive that requires a transclusion with slot name "{0}". ' +
+                    "Element: {1}",
+                  slotName,
+                  startingTag($element),
+                );
+              }
+            } else {
+              return boundTranscludeFn(
+                scope,
+                cloneAttachFn,
+                transcludeControllers,
+                futureParentElement,
+                scopeToChild,
+              );
+            }
+          }
+        };
+
         // executes all directives on the current element
         for (let i = 0, ii = directives.length; i < ii; i++) {
           directive = directives[i];
@@ -1528,6 +1811,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
 
               replaceWith(jqCollection, $compileNode, compileNode);
 
+              /** @type {import("./attributes").AttributeLike} */
               const newTemplateAttrs = { $attr: {} };
 
               // combine directives from the original node and from the template:
@@ -1536,7 +1820,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
               // - collect directives from the template and sort them by priority
               // - combine directives as: processed + template + unprocessed
               const templateDirectives = collectDirectives(
-                compileNode,
+                /** @type {Element} */ (compileNode),
                 [],
                 newTemplateAttrs,
               );
@@ -1569,376 +1853,104 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           if (directive.templateUrl) {
             hasTemplate = true;
             assertNoDuplicate(
-              "template",
-              templateDirective,
-              directive,
-              $compileNode,
-            );
-            templateDirective = directive;
-
-            if (directive.replace) {
-              replaceDirective = directive;
-            }
-
-            nodeLinkFn = compileTemplateUrl(
-              directives.splice(i, directives.length - i),
-              $compileNode,
-              templateAttrs,
-              jqCollection,
-              hasTranscludeDirective && childTranscludeFn,
-              preLinkFns,
-              postLinkFns,
-              {
-                controllerDirectives,
-                newScopeDirective:
-                  newScopeDirective !== directive && newScopeDirective,
-                newIsolateScopeDirective,
-                templateDirective,
-                nonTlbTranscludeDirective,
-              },
-            );
-            ii = directives.length;
-          } else if (directive.compile) {
-            try {
-              linkFn = directive.compile(
-                $compileNode,
-                templateAttrs,
-                childTranscludeFn,
-              );
-              const context = directive.$$originalDirective || directive;
-              if (isFunction(linkFn)) {
-                addLinkFns(null, bind(context, linkFn), attrStart, attrEnd);
-              } else if (linkFn) {
-                addLinkFns(
-                  bind(context, linkFn.pre),
-                  bind(context, linkFn.post),
-                  attrStart,
-                  attrEnd,
-                );
-              }
-            } catch (e) {
-              $exceptionHandler(e, startingTag($compileNode));
-            }
-          }
-
-          if (directive.terminal) {
-            nodeLinkFn.terminal = true;
-            terminalPriority = Math.max(terminalPriority, directive.priority);
-          }
-        }
-
-        nodeLinkFn.scope =
-          newScopeDirective && newScopeDirective.scope === true;
-        nodeLinkFn.transcludeOnThisElement = hasTranscludeDirective;
-        nodeLinkFn.templateOnThisElement = hasTemplate;
-        nodeLinkFn.transclude = childTranscludeFn;
-
-        previousCompileContext.hasElementTranscludeDirective =
-          hasElementTranscludeDirective;
-
-        // might be normal or delayed nodeLinkFn depending on if templateUrl is present
-        return nodeLinkFn;
-
-        /// /////////////////
-
-        function addLinkFns(pre, post, attrStart, attrEnd) {
-          if (pre) {
-            if (attrStart)
-              pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd);
-            pre.require = directive.require;
-            pre.directiveName = directiveName;
-            if (
-              newIsolateScopeDirective === directive ||
-              directive.$$isolateScope
-            ) {
-              pre = cloneAndAnnotateFn(pre, { isolateScope: true });
-            }
-            preLinkFns.push(pre);
-          }
-          if (post) {
-            if (attrStart)
-              post = groupElementsLinkFnWrapper(post, attrStart, attrEnd);
-            post.require = directive.require;
-            post.directiveName = directiveName;
-            if (
-              newIsolateScopeDirective === directive ||
-              directive.$$isolateScope
-            ) {
-              post = cloneAndAnnotateFn(post, { isolateScope: true });
-            }
-            postLinkFns.push(post);
-          }
-        }
-
-        function nodeLinkFn(
-          childLinkFn,
-          scope,
-          linkNode,
-          $rootElement,
-          boundTranscludeFn,
-        ) {
-          let i;
-          let ii;
-          let linkFn;
-          let isolateScope;
-          let controllerScope;
-          let elementControllers;
-          let transcludeFn;
-          let $element;
-          let attrs;
-          let scopeBindingInfo;
-
-          if (compileNode === linkNode) {
-            attrs = templateAttrs;
-            $element = templateAttrs.$$element;
-          } else {
-            $element = JQLite(linkNode);
-            attrs = new Attributes(
-              $rootScope,
-              $animate,
-              $exceptionHandler,
-              $sce,
-              $element,
-              templateAttrs,
-            );
-          }
-
-          controllerScope = scope;
-          if (newIsolateScopeDirective) {
-            isolateScope = scope.$new(true);
-          } else if (newScopeDirective) {
-            controllerScope = scope.$parent;
-          }
-
-          if (boundTranscludeFn) {
-            // track `boundTranscludeFn` so it can be unwrapped if `transcludeFn`
-            // is later passed as `parentBoundTranscludeFn` to `publicLinkFn`
-            transcludeFn = controllersBoundTransclude;
-            transcludeFn.$$boundTransclude = boundTranscludeFn;
-            // expose the slots on the `$transclude` function
-            transcludeFn.isSlotFilled = function (slotName) {
-              return !!boundTranscludeFn.$$slots[slotName];
-            };
-          }
-
-          if (controllerDirectives) {
-            elementControllers = setupControllers(
-              $element,
-              attrs,
-              transcludeFn,
-              controllerDirectives,
-              isolateScope,
-              scope,
-              newIsolateScopeDirective,
-            );
-          }
-
-          if (newIsolateScopeDirective) {
-            isolateScope.$$isolateBindings =
-              newIsolateScopeDirective.$$isolateBindings;
-            scopeBindingInfo = initializeDirectiveBindings(
-              scope,
-              attrs,
-              isolateScope,
-              isolateScope.$$isolateBindings,
-              newIsolateScopeDirective,
-            );
-            if (scopeBindingInfo.removeWatches) {
-              isolateScope.$on("$destroy", scopeBindingInfo.removeWatches);
-            }
-          }
-
-          // Initialize bindToController bindings
-          for (const name in elementControllers) {
-            const controllerDirective = controllerDirectives[name];
-            const controller = elementControllers[name];
-            const bindings = controllerDirective.$$bindings.bindToController;
-
-            controller.instance = controller();
-            $element.data(
-              `$${controllerDirective.name}Controller`,
-              controller.instance,
-            );
-            controller.bindingInfo = initializeDirectiveBindings(
-              controllerScope,
-              attrs,
-              controller.instance,
-              bindings,
-              controllerDirective,
+              "template",
+              templateDirective,
+              directive,
+              $compileNode,
             );
-          }
+            templateDirective = directive;
 
-          // Bind the required controllers to the controller, if `require` is an object and `bindToController` is truthy
-          forEach(controllerDirectives, (controllerDirective, name) => {
-            const { require } = controllerDirective;
-            if (
-              controllerDirective.bindToController &&
-              !Array.isArray(require) &&
-              isObject(require)
-            ) {
-              extend(
-                elementControllers[name].instance,
-                getControllers(name, require, $element, elementControllers),
-              );
+            if (directive.replace) {
+              replaceDirective = directive;
             }
-          });
 
-          // Handle the init and destroy lifecycle hooks on all controllers that have them
-          forEach(elementControllers, (controller) => {
-            const controllerInstance = controller.instance;
-            if (isFunction(controllerInstance.$onChanges)) {
-              try {
-                controllerInstance.$onChanges(
-                  controller.bindingInfo.initialChanges,
+            nodeLinkFn = compileTemplateUrl(
+              directives.splice(i, directives.length - i),
+              $compileNode,
+              templateAttrs,
+              jqCollection,
+              hasTranscludeDirective && childTranscludeFn,
+              preLinkFns,
+              postLinkFns,
+              {
+                controllerDirectives,
+                newScopeDirective:
+                  newScopeDirective !== directive && newScopeDirective,
+                newIsolateScopeDirective,
+                templateDirective,
+                nonTlbTranscludeDirective,
+              },
+            );
+            ii = directives.length;
+          } else if (directive.compile) {
+            try {
+              linkFn = directive.compile(
+                $compileNode,
+                templateAttrs,
+                childTranscludeFn,
+              );
+              const context = directive.$$originalDirective || directive;
+              if (isFunction(linkFn)) {
+                addLinkFns(null, bind(context, linkFn), attrStart, attrEnd);
+              } else if (linkFn) {
+                addLinkFns(
+                  bind(context, linkFn.pre),
+                  bind(context, linkFn.post),
+                  attrStart,
+                  attrEnd,
                 );
-              } catch (e) {
-                $exceptionHandler(e);
               }
+            } catch (e) {
+              $exceptionHandler(e, startingTag($compileNode));
             }
-            if (isFunction(controllerInstance.$onInit)) {
-              try {
-                controllerInstance.$onInit();
-              } catch (e) {
-                $exceptionHandler(e);
-              }
-            }
-            if (isFunction(controllerInstance.$doCheck)) {
-              controllerScope.$watch(() => {
-                controllerInstance.$doCheck();
-              });
-              controllerInstance.$doCheck();
-            }
-            if (isFunction(controllerInstance.$onDestroy)) {
-              controllerScope.$on("$destroy", () => {
-                controllerInstance.$onDestroy();
-              });
-            }
-          });
-
-          // PRELINKING
-          for (i = 0, ii = preLinkFns.length; i < ii; i++) {
-            linkFn = preLinkFns[i];
-            invokeLinkFn(
-              linkFn,
-              linkFn.isolateScope ? isolateScope : scope,
-              $element,
-              attrs,
-              linkFn.require &&
-                getControllers(
-                  linkFn.directiveName,
-                  linkFn.require,
-                  $element,
-                  elementControllers,
-                ),
-              transcludeFn,
-            );
           }
 
-          // RECURSION
-          // We only pass the isolate scope, if the isolate directive has a template,
-          // otherwise the child elements do not belong to the isolate directive.
-          var scopeToChild = scope;
-          if (
-            newIsolateScopeDirective &&
-            (newIsolateScopeDirective.template ||
-              newIsolateScopeDirective.templateUrl === null)
-          ) {
-            scopeToChild = isolateScope;
-          }
-          if (childLinkFn) {
-            childLinkFn(
-              scopeToChild,
-              linkNode.childNodes,
-              undefined,
-              boundTranscludeFn,
-            );
+          if (directive.terminal) {
+            nodeLinkFn.terminal = true;
+            terminalPriority = Math.max(terminalPriority, directive.priority);
           }
+        }
 
-          // POSTLINKING
-          for (i = postLinkFns.length - 1; i >= 0; i--) {
-            linkFn = postLinkFns[i];
-            invokeLinkFn(
-              linkFn,
-              linkFn.isolateScope ? isolateScope : scope,
-              $element,
-              attrs,
-              linkFn.require &&
-                getControllers(
-                  linkFn.directiveName,
-                  linkFn.require,
-                  $element,
-                  elementControllers,
-                ),
-              transcludeFn,
-            );
-          }
+        nodeLinkFn.scope =
+          newScopeDirective && newScopeDirective.scope === true;
+        nodeLinkFn.transcludeOnThisElement = hasTranscludeDirective;
+        nodeLinkFn.templateOnThisElement = hasTemplate;
+        nodeLinkFn.transclude = childTranscludeFn;
 
-          // Trigger $postLink lifecycle hooks
-          forEach(elementControllers, (controller) => {
-            const controllerInstance = controller.instance;
-            if (isFunction(controllerInstance.$postLink)) {
-              controllerInstance.$postLink();
-            }
-          });
+        previousCompileContext.hasElementTranscludeDirective =
+          hasElementTranscludeDirective;
 
-          // This is the function that is injected as `$transclude`.
-          // Note: all arguments are optional!
-          function controllersBoundTransclude(
-            scope,
-            cloneAttachFn,
-            futureParentElement,
-            slotName,
-          ) {
-            let transcludeControllers;
-            // No scope passed in:
-            if (!isScope(scope)) {
-              slotName = futureParentElement;
-              futureParentElement = cloneAttachFn;
-              cloneAttachFn = scope;
-              scope = undefined;
-            }
+        // might be normal or delayed nodeLinkFn depending on if templateUrl is present
+        return nodeLinkFn;
 
-            if (hasElementTranscludeDirective) {
-              transcludeControllers = elementControllers;
-            }
-            if (!futureParentElement) {
-              futureParentElement = hasElementTranscludeDirective
-                ? $element.parent()
-                : $element;
+        /// /////////////////
+
+        function addLinkFns(pre, post, attrStart, attrEnd) {
+          if (pre) {
+            if (attrStart)
+              pre = groupElementsLinkFnWrapper(pre, attrStart, attrEnd);
+            pre.require = directive.require;
+            pre.directiveName = directiveName;
+            if (
+              newIsolateScopeDirective === directive ||
+              directive.$$isolateScope
+            ) {
+              pre = cloneAndAnnotateFn(pre, { isolateScope: true });
             }
-            if (slotName) {
-              // slotTranscludeFn can be one of three things:
-              //  * a transclude function - a filled slot
-              //  * `null` - an optional slot that was not filled
-              //  * `undefined` - a slot that was not declared (i.e. invalid)
-              const slotTranscludeFn = boundTranscludeFn.$$slots[slotName];
-              if (slotTranscludeFn) {
-                return slotTranscludeFn(
-                  scope,
-                  cloneAttachFn,
-                  transcludeControllers,
-                  futureParentElement,
-                  scopeToChild,
-                );
-              }
-              if (isUndefined(slotTranscludeFn)) {
-                throw $compileMinErr(
-                  "noslot",
-                  'No parent directive that requires a transclusion with slot name "{0}". ' +
-                    "Element: {1}",
-                  slotName,
-                  startingTag($element),
-                );
-              }
-            } else {
-              return boundTranscludeFn(
-                scope,
-                cloneAttachFn,
-                transcludeControllers,
-                futureParentElement,
-                scopeToChild,
-              );
+            preLinkFns.push(pre);
+          }
+          if (post) {
+            if (attrStart)
+              post = groupElementsLinkFnWrapper(post, attrStart, attrEnd);
+            post.require = directive.require;
+            post.directiveName = directiveName;
+            if (
+              newIsolateScopeDirective === directive ||
+              directive.$$isolateScope
+            ) {
+              post = cloneAndAnnotateFn(post, { isolateScope: true });
             }
+            postLinkFns.push(post);
           }
         }
       }
@@ -2223,6 +2235,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         previousCompileContext,
       ) {
         let linkQueue = [];
+        /** @type {any} */
         let afterTemplateNodeLinkFn;
         let afterTemplateChildLinkFn;
         const beforeTemplateCompileNode = $compileNode[0];
@@ -2518,6 +2531,61 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
         return sanitizeSrcset($sce.valueOf(value), "ng-prop-srcset");
       }
 
+      function sanitizeSrcset(value, invokeType) {
+        if (!value) {
+          return value;
+        }
+        if (!isString(value)) {
+          throw $compileMinErr(
+            "srcset",
+            'Can\'t pass trusted values to `{0}`: "{1}"',
+            invokeType,
+            value.toString(),
+          );
+        }
+
+        // Such values are a bit too complex to handle automatically inside $sce.
+        // Instead, we sanitize each of the URIs individually, which works, even dynamically.
+
+        // It's not possible to work around this using `$sce.trustAsMediaUrl`.
+        // If you want to programmatically set explicitly trusted unsafe URLs, you should use
+        // `$sce.trustAsHtml` on the whole `img` tag and inject it into the DOM using the
+        // `ng-bind-html` directive.
+
+        var result = "";
+
+        // first check if there are spaces because it's not the same pattern
+        var trimmedSrcset = trim(value);
+        //                (   999x   ,|   999w   ,|   ,|,   )
+        var srcPattern = /(\s+\d+x\s*,|\s+\d+w\s*,|\s+,|,\s+)/;
+        var pattern = /\s/.test(trimmedSrcset) ? srcPattern : /(,)/;
+
+        // split srcset into tuple of uri and descriptor except for the last item
+        var rawUris = trimmedSrcset.split(pattern);
+
+        // for each tuples
+        var nbrUrisWith2parts = Math.floor(rawUris.length / 2);
+        for (var i = 0; i < nbrUrisWith2parts; i++) {
+          var innerIdx = i * 2;
+          // sanitize the uri
+          result += $sce.getTrustedMediaUrl(trim(rawUris[innerIdx]));
+          // add the descriptor
+          result += " " + trim(rawUris[innerIdx + 1]);
+        }
+
+        // split the last item into uri and descriptor
+        var lastTuple = trim(rawUris[i * 2]).split(/\s/);
+
+        // sanitize the last uri
+        result += $sce.getTrustedMediaUrl(trim(lastTuple[0]));
+
+        // and add the last descriptor if any
+        if (lastTuple.length === 2) {
+          result += " " + trim(lastTuple[1]);
+        }
+        return result;
+      }
+
       function addPropertyDirective(node, directives, attrName, propName) {
         if (EVENT_HANDLER_ATTR_REGEXP.test(propName)) {
           throw $compileMinErr(
@@ -2699,13 +2767,6 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
                 }
               }
               $rootElement.length -= removeCount - 1;
-
-              // If the replaced element is also the jQuery .context then replace it
-              // .context is a deprecated jQuery api, so we should set it only when jQuery set it
-              // http://api.jquery.com/context/
-              if ($rootElement.context === firstElementToRemove) {
-                $rootElement.context = newNode;
-              }
               break;
             }
           }
@@ -2728,7 +2789,10 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
           // Copy over user data (that includes AngularJS's $scope etc.). Don't copy private
           // data here because there's no public interface in jQuery to do that and copying over
           // event listeners (which is the main use of private data) wouldn't work anyway.
-          getOrSetCacheData(newNode, getOrSetCacheData(firstElementToRemove));
+          getOrSetCacheData(
+            /** @type {Element} */ (newNode),
+            getOrSetCacheData(firstElementToRemove),
+          );
 
           // Remove $destroy event listeners from `firstElementToRemove`
           JQLite(firstElementToRemove).off("$destroy");
@@ -2807,7 +2871,7 @@ export function $CompileProvider($provide, $$sanitizeUriProvider) {
 
           switch (mode) {
             case "@":
-              if (!optional && !hasOwnProperty.call(attrs, attrName)) {
+              if (!optional && !Object.hasOwnProperty.call(attrs, attrName)) {
                 strictBindingsCheck(attrName, directive.name);
                 destination[scopeName] = attrs[attrName] = undefined;
               }