@angular/compiler - npm Package Compare versions

Comparing version 4.0.0-beta.8 to 4.0.0-rc.0

bundles/compiler-testing.umd.js

 /**
- * @license Angular v4.0.0-beta.8
+ * @license Angular v4.0.0-rc.0
  * (c) 2010-2017 Google, Inc. https://angular.io/
@@ -7,9 +7,100 @@ * License: MIT
 (function (global, factory) {
-    typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@angular/core'), require('@angular/compiler'), require('@angular/core/testing')) :
-    typeof define === 'function' && define.amd ? define(['exports', '@angular/core', '@angular/compiler', '@angular/core/testing'], factory) :
-    (factory((global.ng = global.ng || {}, global.ng.compiler = global.ng.compiler || {}, global.ng.compiler.testing = global.ng.compiler.testing || {}),global.ng.core,global.ng.compiler,global.ng.core.testing));
-}(this, function (exports,_angular_core,_angular_compiler,_angular_core_testing) { 'use strict';
+    if (typeof define === "function" && define.amd) {
+        define('@angular/core/testing', ['exports', '@angular/core', '@angular/compiler', '@angular/core/testing'], factory);
+    } else if (typeof exports !== "undefined") {
+        factory(exports, require('@angular/core'), require('@angular/compiler'), require('@angular/core/testing'));
+    } else {
+        var mod = {
+            exports: {}
+        };
+        factory(mod.exports, global.ng.core, global.ng.compiler, global.ng.core.testing);
+        global.ng = global.ng || {};
+        global.ng.core = global.ng.core || {};
+        global.ng.core.testing = mod.exports;
+    }
+})(this, function (exports, _core, _compiler2, _testing) {
+    'use strict';
 
-    var MockSchemaRegistry = (function () {
+    Object.defineProperty(exports, "__esModule", {
+        value: true
+    });
+    exports.MockPipeResolver = exports.MockNgModuleResolver = exports.MockDirectiveResolver = exports.MockSchemaRegistry = exports.platformCoreDynamicTesting = exports.TestingCompilerImpl = exports.TestingCompilerFactoryImpl = undefined;
+
+    function _possibleConstructorReturn(self, call) {
+        if (!self) {
+            throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+        }
+
+        return call && (typeof call === "object" || typeof call === "function") ? call : self;
+    }
+
+    var _get = function get(object, property, receiver) {
+        if (object === null) object = Function.prototype;
+        var desc = Object.getOwnPropertyDescriptor(object, property);
+
+        if (desc === undefined) {
+            var parent = Object.getPrototypeOf(object);
+
+            if (parent === null) {
+                return undefined;
+            } else {
+                return get(parent, property, receiver);
+            }
+        } else if ("value" in desc) {
+            return desc.value;
+        } else {
+            var getter = desc.get;
+
+            if (getter === undefined) {
+                return undefined;
+            }
+
+            return getter.call(receiver);
+        }
+    };
+
+    function _inherits(subClass, superClass) {
+        if (typeof superClass !== "function" && superClass !== null) {
+            throw new TypeError("Super expression must either be null or a function, not " + typeof superClass);
+        }
+
+        subClass.prototype = Object.create(superClass && superClass.prototype, {
+            constructor: {
+                value: subClass,
+                enumerable: false,
+                writable: true,
+                configurable: true
+            }
+        });
+        if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : subClass.__proto__ = superClass;
+    }
+
+    function _classCallCheck(instance, Constructor) {
+        if (!(instance instanceof Constructor)) {
+            throw new TypeError("Cannot call a class as a function");
+        }
+    }
+
+    var _createClass = function () {
+        function defineProperties(target, props) {
+            for (var i = 0; i < props.length; i++) {
+                var descriptor = props[i];
+                descriptor.enumerable = descriptor.enumerable || false;
+                descriptor.configurable = true;
+                if ("value" in descriptor) descriptor.writable = true;
+                Object.defineProperty(target, descriptor.key, descriptor);
+            }
+        }
+
+        return function (Constructor, protoProps, staticProps) {
+            if (protoProps) defineProperties(Constructor.prototype, protoProps);
+            if (staticProps) defineProperties(Constructor, staticProps);
+            return Constructor;
+        };
+    }();
+
+    var MockSchemaRegistry = function () {
         function MockSchemaRegistry(existingProperties, attrPropMapping, existingElements, invalidProperties, invalidAttributes) {
+            _classCallCheck(this, MockSchemaRegistry);
+
             this.existingProperties = existingProperties;
@@ -21,41 +112,70 @@ this.attrPropMapping = attrPropMapping;
         }
-        MockSchemaRegistry.prototype.hasProperty = function (tagName, property, schemas) {
-            var value = this.existingProperties[property];
-            return value === void 0 ? true : value;
-        };
-        MockSchemaRegistry.prototype.hasElement = function (tagName, schemaMetas) {
-            var value = this.existingElements[tagName.toLowerCase()];
-            return value === void 0 ? true : value;
-        };
-        MockSchemaRegistry.prototype.allKnownElementNames = function () { return Object.keys(this.existingElements); };
-        MockSchemaRegistry.prototype.securityContext = function (selector, property, isAttribute) {
-            return _angular_core.SecurityContext.NONE;
-        };
-        MockSchemaRegistry.prototype.getMappedPropName = function (attrName) { return this.attrPropMapping[attrName] || attrName; };
-        MockSchemaRegistry.prototype.getDefaultComponentElementName = function () { return 'ng-component'; };
-        MockSchemaRegistry.prototype.validateProperty = function (name) {
-            if (this.invalidProperties.indexOf(name) > -1) {
-                return { error: true, msg: "Binding to property '" + name + "' is disallowed for security reasons" };
+
+        _createClass(MockSchemaRegistry, [{
+            key: 'hasProperty',
+            value: function hasProperty(tagName, property, schemas) {
+                var value = this.existingProperties[property];
+                return value === void 0 ? true : value;
             }
-            else {
-                return { error: false };
+        }, {
+            key: 'hasElement',
+            value: function hasElement(tagName, schemaMetas) {
+                var value = this.existingElements[tagName.toLowerCase()];
+                return value === void 0 ? true : value;
             }
-        };
-        MockSchemaRegistry.prototype.validateAttribute = function (name) {
-            if (this.invalidAttributes.indexOf(name) > -1) {
-                return {
-                    error: true,
-                    msg: "Binding to attribute '" + name + "' is disallowed for security reasons"
-                };
+        }, {
+            key: 'allKnownElementNames',
+            value: function allKnownElementNames() {
+                return Object.keys(this.existingElements);
             }
-            else {
-                return { error: false };
+        }, {
+            key: 'securityContext',
+            value: function securityContext(selector, property, isAttribute) {
+                return _core.SecurityContext.NONE;
             }
-        };
-        MockSchemaRegistry.prototype.normalizeAnimationStyleProperty = function (propName) { return propName; };
-        MockSchemaRegistry.prototype.normalizeAnimationStyleValue = function (camelCaseProp, userProvidedProp, val) {
-            return { error: null, value: val.toString() };
-        };
+        }, {
+            key: 'getMappedPropName',
+            value: function getMappedPropName(attrName) {
+                return this.attrPropMapping[attrName] || attrName;
+            }
+        }, {
+            key: 'getDefaultComponentElementName',
+            value: function getDefaultComponentElementName() {
+                return 'ng-component';
+            }
+        }, {
+            key: 'validateProperty',
+            value: function validateProperty(name) {
+                if (this.invalidProperties.indexOf(name) > -1) {
+                    return { error: true, msg: 'Binding to property \'' + name + '\' is disallowed for security reasons' };
+                } else {
+                    return { error: false };
+                }
+            }
+        }, {
+            key: 'validateAttribute',
+            value: function validateAttribute(name) {
+                if (this.invalidAttributes.indexOf(name) > -1) {
+                    return {
+                        error: true,
+                        msg: 'Binding to attribute \'' + name + '\' is disallowed for security reasons'
+                    };
+                } else {
+                    return { error: false };
+                }
+            }
+        }, {
+            key: 'normalizeAnimationStyleProperty',
+            value: function normalizeAnimationStyleProperty(propName) {
+                return propName;
+            }
+        }, {
+            key: 'normalizeAnimationStyleValue',
+            value: function normalizeAnimationStyleValue(camelCaseProp, userProvidedProp, val) {
+                return { error: null, value: val.toString() };
+            }
+        }]);
+
         return MockSchemaRegistry;
-    }());
+    }();
 
@@ -73,6 +193,6 @@ function isPresent(obj) {
         if (token.overriddenName) {
-            return "" + token.overriddenName;
+            return '' + token.overriddenName;
         }
         if (token.name) {
-            return "" + token.name;
+            return '' + token.name;
         }
@@ -84,7 +204,2 @@ var res = token.toString();
 
-    var __extends = (this && this.__extends) || function (d, b) {
-        for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
     /**
@@ -94,6 +209,11 @@ * An implementation of {@link DirectiveResolver} that allows overriding
      */
-    var MockDirectiveResolver = (function (_super) {
-        __extends(MockDirectiveResolver, _super);
+
+    var MockDirectiveResolver = function (_DirectiveResolver) {
+        _inherits(MockDirectiveResolver, _DirectiveResolver);
+
         function MockDirectiveResolver(_injector) {
-            var _this = _super.call(this) || this;
+            _classCallCheck(this, MockDirectiveResolver);
+
+            var _this = _possibleConstructorReturn(this, (MockDirectiveResolver.__proto__ || Object.getPrototypeOf(MockDirectiveResolver)).call(this));
+
             _this._injector = _injector;
@@ -105,51 +225,69 @@ _this._directives = new Map();
             _this._inlineTemplates = new Map();
-            _this._animations = new Map();
             return _this;
         }
-        Object.defineProperty(MockDirectiveResolver.prototype, "_compiler", {
-            get: function () { return this._injector.get(_angular_core.Compiler); },
-            enumerable: true,
-            configurable: true
-        });
-        MockDirectiveResolver.prototype._clearCacheFor = function (component) { this._compiler.clearCacheFor(component); };
-        MockDirectiveResolver.prototype.resolve = function (type, throwIfNotFound) {
-            if (throwIfNotFound === void 0) { throwIfNotFound = true; }
-            var metadata = this._directives.get(type);
-            if (!metadata) {
-                metadata = _super.prototype.resolve.call(this, type, throwIfNotFound);
+
+        _createClass(MockDirectiveResolver, [{
+            key: '_clearCacheFor',
+            value: function _clearCacheFor(component) {
+                this._compiler.clearCacheFor(component);
             }
-            if (!metadata) {
-                return null;
-            }
-            var providerOverrides = this._providerOverrides.get(type);
-            var viewProviderOverrides = this._viewProviderOverrides.get(type);
-            var providers = metadata.providers;
-            if (isPresent(providerOverrides)) {
-                var originalViewProviders = metadata.providers || [];
-                providers = originalViewProviders.concat(providerOverrides);
-            }
-            if (metadata instanceof _angular_core.Component) {
-                var viewProviders = metadata.viewProviders;
-                if (isPresent(viewProviderOverrides)) {
-                    var originalViewProviders = metadata.viewProviders || [];
-                    viewProviders = originalViewProviders.concat(viewProviderOverrides);
+        }, {
+            key: 'resolve',
+            value: function resolve(type) {
+                var throwIfNotFound = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+                var metadata = this._directives.get(type);
+                if (!metadata) {
+                    metadata = _get(MockDirectiveResolver.prototype.__proto__ || Object.getPrototypeOf(MockDirectiveResolver.prototype), 'resolve', this).call(this, type, throwIfNotFound);
                 }
-                var view = this._views.get(type);
-                if (!view) {
-                    view = metadata;
+                if (!metadata) {
+                    return null;
                 }
-                var animations = view.animations;
-                var templateUrl = view.templateUrl;
-                var inlineAnimations = this._animations.get(type);
-                if (isPresent(inlineAnimations)) {
-                    animations = inlineAnimations;
+                var providerOverrides = this._providerOverrides.get(type);
+                var viewProviderOverrides = this._viewProviderOverrides.get(type);
+                var providers = metadata.providers;
+                if (isPresent(providerOverrides)) {
+                    var originalViewProviders = metadata.providers || [];
+                    providers = originalViewProviders.concat(providerOverrides);
                 }
-                var inlineTemplate = this._inlineTemplates.get(type);
-                if (isPresent(inlineTemplate)) {
-                    templateUrl = null;
+                if (metadata instanceof _core.Component) {
+                    var viewProviders = metadata.viewProviders;
+                    if (isPresent(viewProviderOverrides)) {
+                        var _originalViewProviders = metadata.viewProviders || [];
+                        viewProviders = _originalViewProviders.concat(viewProviderOverrides);
+                    }
+                    var view = this._views.get(type);
+                    if (!view) {
+                        view = metadata;
+                    }
+                    var animations = view.animations;
+                    var templateUrl = view.templateUrl;
+                    var inlineTemplate = this._inlineTemplates.get(type);
+                    if (isPresent(inlineTemplate)) {
+                        templateUrl = null;
+                    } else {
+                        inlineTemplate = view.template;
+                    }
+                    return new _core.Component({
+                        selector: metadata.selector,
+                        inputs: metadata.inputs,
+                        outputs: metadata.outputs,
+                        host: metadata.host,
+                        exportAs: metadata.exportAs,
+                        moduleId: metadata.moduleId,
+                        queries: metadata.queries,
+                        changeDetection: metadata.changeDetection,
+                        providers: providers,
+                        viewProviders: viewProviders,
+                        entryComponents: metadata.entryComponents,
+                        template: inlineTemplate,
+                        templateUrl: templateUrl,
+                        animations: animations,
+                        styles: view.styles,
+                        styleUrls: view.styleUrls,
+                        encapsulation: view.encapsulation,
+                        interpolation: view.interpolation
+                    });
                 }
-                else {
-                    inlineTemplate = view.template;
-                }
-                return new _angular_core.Component({
+                return new _core.Directive({
                     selector: metadata.selector,
@@ -159,90 +297,64 @@ inputs: metadata.inputs,
                     host: metadata.host,
+                    providers: providers,
                     exportAs: metadata.exportAs,
-                    moduleId: metadata.moduleId,
-                    queries: metadata.queries,
-                    changeDetection: metadata.changeDetection,
-                    providers: providers,
-                    viewProviders: viewProviders,
-                    entryComponents: metadata.entryComponents,
-                    template: inlineTemplate,
-                    templateUrl: templateUrl,
-                    animations: animations,
-                    styles: view.styles,
-                    styleUrls: view.styleUrls,
-                    encapsulation: view.encapsulation,
-                    interpolation: view.interpolation
+                    queries: metadata.queries
                 });
             }
-            return new _angular_core.Directive({
-                selector: metadata.selector,
-                inputs: metadata.inputs,
-                outputs: metadata.outputs,
-                host: metadata.host,
-                providers: providers,
-                exportAs: metadata.exportAs,
-                queries: metadata.queries
-            });
-        };
-        /**
-         * Overrides the {@link Directive} for a directive.
-         */
-        MockDirectiveResolver.prototype.setDirective = function (type, metadata) {
-            this._directives.set(type, metadata);
-            this._clearCacheFor(type);
-        };
-        MockDirectiveResolver.prototype.setProvidersOverride = function (type, providers) {
-            this._providerOverrides.set(type, providers);
-            this._clearCacheFor(type);
-        };
-        MockDirectiveResolver.prototype.setViewProvidersOverride = function (type, viewProviders) {
-            this._viewProviderOverrides.set(type, viewProviders);
-            this._clearCacheFor(type);
-        };
-        /**
-         * Overrides the {@link ViewMetadata} for a component.
-         */
-        MockDirectiveResolver.prototype.setView = function (component, view) {
-            this._views.set(component, view);
-            this._clearCacheFor(component);
-        };
-        /**
-         * Overrides the inline template for a component - other configuration remains unchanged.
-         */
-        MockDirectiveResolver.prototype.setInlineTemplate = function (component, template) {
-            this._inlineTemplates.set(component, template);
-            this._clearCacheFor(component);
-        };
-        MockDirectiveResolver.prototype.setAnimations = function (component, animations) {
-            this._animations.set(component, animations);
-            this._clearCacheFor(component);
-        };
+        }, {
+            key: 'setDirective',
+            value: function setDirective(type, metadata) {
+                this._directives.set(type, metadata);
+                this._clearCacheFor(type);
+            }
+        }, {
+            key: 'setProvidersOverride',
+            value: function setProvidersOverride(type, providers) {
+                this._providerOverrides.set(type, providers);
+                this._clearCacheFor(type);
+            }
+        }, {
+            key: 'setViewProvidersOverride',
+            value: function setViewProvidersOverride(type, viewProviders) {
+                this._viewProviderOverrides.set(type, viewProviders);
+                this._clearCacheFor(type);
+            }
+        }, {
+            key: 'setView',
+            value: function setView(component, view) {
+                this._views.set(component, view);
+                this._clearCacheFor(component);
+            }
+        }, {
+            key: 'setInlineTemplate',
+            value: function setInlineTemplate(component, template) {
+                this._inlineTemplates.set(component, template);
+                this._clearCacheFor(component);
+            }
+        }, {
+            key: '_compiler',
+            get: function get() {
+                return this._injector.get(_core.Compiler);
+            }
+        }]);
+
         return MockDirectiveResolver;
-    }(_angular_compiler.DirectiveResolver));
-    MockDirectiveResolver.decorators = [
-        { type: _angular_core.Injectable },
-    ];
+    }(_compiler2.DirectiveResolver);
+
+    MockDirectiveResolver.decorators = [{ type: _core.Injectable }];
     /** @nocollapse */
-    MockDirectiveResolver.ctorParameters = function () { return [
-        { type: _angular_core.Injector, },
-    ]; };
+    MockDirectiveResolver.ctorParameters = function () {
+        return [{ type: _core.Injector }];
+    };
 
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * 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 __extends$1 = (this && this.__extends) || function (d, b) {
-        for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-    var MockNgModuleResolver = (function (_super) {
-        __extends$1(MockNgModuleResolver, _super);
+    var MockNgModuleResolver = function (_NgModuleResolver) {
+        _inherits(MockNgModuleResolver, _NgModuleResolver);
+
         function MockNgModuleResolver(_injector) {
-            var _this = _super.call(this) || this;
-            _this._injector = _injector;
-            _this._ngModules = new Map();
-            return _this;
+            _classCallCheck(this, MockNgModuleResolver);
+
+            var _this2 = _possibleConstructorReturn(this, (MockNgModuleResolver.__proto__ || Object.getPrototypeOf(MockNgModuleResolver)).call(this));
+
+            _this2._injector = _injector;
+            _this2._ngModules = new Map();
+            return _this2;
         }
@@ -252,94 +364,95 @@ /**
          */
-        MockNgModuleResolver.prototype.setNgModule = function (type, metadata) {
-            this._ngModules.set(type, metadata);
-            this._clearCacheFor(type);
-        };
-        /**
-         * Returns the {@link NgModule} for a module:
-         * - Set the {@link NgModule} to the overridden view when it exists or fallback to the
-         * default
-         * `NgModuleResolver`, see `setNgModule`.
-         */
-        MockNgModuleResolver.prototype.resolve = function (type, throwIfNotFound) {
-            if (throwIfNotFound === void 0) { throwIfNotFound = true; }
-            return this._ngModules.get(type) || _super.prototype.resolve.call(this, type, throwIfNotFound);
-        };
-        Object.defineProperty(MockNgModuleResolver.prototype, "_compiler", {
-            get: function () { return this._injector.get(_angular_core.Compiler); },
-            enumerable: true,
-            configurable: true
-        });
-        MockNgModuleResolver.prototype._clearCacheFor = function (component) { this._compiler.clearCacheFor(component); };
+
+
+        _createClass(MockNgModuleResolver, [{
+            key: 'setNgModule',
+            value: function setNgModule(type, metadata) {
+                this._ngModules.set(type, metadata);
+                this._clearCacheFor(type);
+            }
+        }, {
+            key: 'resolve',
+            value: function resolve(type) {
+                var throwIfNotFound = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+                return this._ngModules.get(type) || _get(MockNgModuleResolver.prototype.__proto__ || Object.getPrototypeOf(MockNgModuleResolver.prototype), 'resolve', this).call(this, type, throwIfNotFound);
+            }
+        }, {
+            key: '_clearCacheFor',
+            value: function _clearCacheFor(component) {
+                this._compiler.clearCacheFor(component);
+            }
+        }, {
+            key: '_compiler',
+            get: function get() {
+                return this._injector.get(_core.Compiler);
+            }
+        }]);
+
         return MockNgModuleResolver;
-    }(_angular_compiler.NgModuleResolver));
-    MockNgModuleResolver.decorators = [
-        { type: _angular_core.Injectable },
-    ];
+    }(_compiler2.NgModuleResolver);
+
+    MockNgModuleResolver.decorators = [{ type: _core.Injectable }];
     /** @nocollapse */
-    MockNgModuleResolver.ctorParameters = function () { return [
-        { type: _angular_core.Injector, },
-    ]; };
+    MockNgModuleResolver.ctorParameters = function () {
+        return [{ type: _core.Injector }];
+    };
 
-    /**
-     * @license
-     * Copyright Google Inc. All Rights Reserved.
-     *
-     * 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 __extends$2 = (this && this.__extends) || function (d, b) {
-        for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p];
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-    var MockPipeResolver = (function (_super) {
-        __extends$2(MockPipeResolver, _super);
+    var MockPipeResolver = function (_PipeResolver) {
+        _inherits(MockPipeResolver, _PipeResolver);
+
         function MockPipeResolver(_injector) {
-            var _this = _super.call(this) || this;
-            _this._injector = _injector;
-            _this._pipes = new Map();
-            return _this;
+            _classCallCheck(this, MockPipeResolver);
+
+            var _this3 = _possibleConstructorReturn(this, (MockPipeResolver.__proto__ || Object.getPrototypeOf(MockPipeResolver)).call(this));
+
+            _this3._injector = _injector;
+            _this3._pipes = new Map();
+            return _this3;
         }
-        Object.defineProperty(MockPipeResolver.prototype, "_compiler", {
-            get: function () { return this._injector.get(_angular_core.Compiler); },
-            enumerable: true,
-            configurable: true
-        });
-        MockPipeResolver.prototype._clearCacheFor = function (pipe) { this._compiler.clearCacheFor(pipe); };
-        /**
-         * Overrides the {@link Pipe} for a pipe.
-         */
-        MockPipeResolver.prototype.setPipe = function (type, metadata) {
-            this._pipes.set(type, metadata);
-            this._clearCacheFor(type);
-        };
-        /**
-         * Returns the {@link Pipe} for a pipe:
-         * - Set the {@link Pipe} to the overridden view when it exists or fallback to the
-         * default
-         * `PipeResolver`, see `setPipe`.
-         */
-        MockPipeResolver.prototype.resolve = function (type, throwIfNotFound) {
-            if (throwIfNotFound === void 0) { throwIfNotFound = true; }
-            var metadata = this._pipes.get(type);
-            if (!metadata) {
-                metadata = _super.prototype.resolve.call(this, type, throwIfNotFound);
+
+        _createClass(MockPipeResolver, [{
+            key: '_clearCacheFor',
+            value: function _clearCacheFor(pipe) {
+                this._compiler.clearCacheFor(pipe);
             }
-            return metadata;
-        };
+        }, {
+            key: 'setPipe',
+            value: function setPipe(type, metadata) {
+                this._pipes.set(type, metadata);
+                this._clearCacheFor(type);
+            }
+        }, {
+            key: 'resolve',
+            value: function resolve(type) {
+                var throwIfNotFound = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+
+                var metadata = this._pipes.get(type);
+                if (!metadata) {
+                    metadata = _get(MockPipeResolver.prototype.__proto__ || Object.getPrototypeOf(MockPipeResolver.prototype), 'resolve', this).call(this, type, throwIfNotFound);
+                }
+                return metadata;
+            }
+        }, {
+            key: '_compiler',
+            get: function get() {
+                return this._injector.get(_core.Compiler);
+            }
+        }]);
+
         return MockPipeResolver;
-    }(_angular_compiler.PipeResolver));
-    MockPipeResolver.decorators = [
-        { type: _angular_core.Injectable },
-    ];
+    }(_compiler2.PipeResolver);
+
+    MockPipeResolver.decorators = [{ type: _core.Injectable }];
     /** @nocollapse */
-    MockPipeResolver.ctorParameters = function () { return [
-        { type: _angular_core.Injector, },
-    ]; };
+    MockPipeResolver.ctorParameters = function () {
+        return [{ type: _core.Injector }];
+    };
 
-    var TestingCompilerFactory = _angular_core_testing.__core_private_testing__.TestingCompilerFactory;
+    var _nextReferenceId = 0;
 
-    var _nextReferenceId = 0;
-    var MetadataOverrider = (function () {
+    var MetadataOverrider = function () {
         function MetadataOverrider() {
+            _classCallCheck(this, MetadataOverrider);
+
             this._references = new Map();
@@ -351,43 +464,57 @@ }
          */
-        MetadataOverrider.prototype.overrideMetadata = function (metadataClass, oldMetadata, override) {
-            var props = {};
-            if (oldMetadata) {
-                _valueProps(oldMetadata).forEach(function (prop) { return props[prop] = oldMetadata[prop]; });
-            }
-            if (override.set) {
-                if (override.remove || override.add) {
-                    throw new Error("Cannot set and add/remove " + stringify(metadataClass) + " at the same time!");
+
+
+        _createClass(MetadataOverrider, [{
+            key: 'overrideMetadata',
+            value: function overrideMetadata(metadataClass, oldMetadata, override) {
+                var props = {};
+                if (oldMetadata) {
+                    _valueProps(oldMetadata).forEach(function (prop) {
+                        return props[prop] = oldMetadata[prop];
+                    });
                 }
-                setMetadata(props, override.set);
+                if (override.set) {
+                    if (override.remove || override.add) {
+                        throw new Error('Cannot set and add/remove ' + stringify(metadataClass) + ' at the same time!');
+                    }
+                    setMetadata(props, override.set);
+                }
+                if (override.remove) {
+                    removeMetadata(props, override.remove, this._references);
+                }
+                if (override.add) {
+                    addMetadata(props, override.add);
+                }
+                return new metadataClass(props);
             }
-            if (override.remove) {
-                removeMetadata(props, override.remove, this._references);
-            }
-            if (override.add) {
-                addMetadata(props, override.add);
-            }
-            return new metadataClass(props);
-        };
+        }]);
+
         return MetadataOverrider;
-    }());
+    }();
+
     function removeMetadata(metadata, remove, references) {
         var removeObjects = new Set();
-        var _loop_1 = function (prop) {
+
+        var _loop = function _loop(prop) {
             var removeValue = remove[prop];
             if (removeValue instanceof Array) {
-                removeValue.forEach(function (value) { removeObjects.add(_propHashKey(prop, value, references)); });
-            }
-            else {
+                removeValue.forEach(function (value) {
+                    removeObjects.add(_propHashKey(prop, value, references));
+                });
+            } else {
                 removeObjects.add(_propHashKey(prop, removeValue, references));
             }
         };
+
         for (var prop in remove) {
-            _loop_1(prop);
+            _loop(prop);
         }
-        var _loop_2 = function (prop) {
+
+        var _loop2 = function _loop2(prop) {
             var propValue = metadata[prop];
             if (propValue instanceof Array) {
-                metadata[prop] = propValue.filter(function (value) { return !removeObjects.has(_propHashKey(prop, value, references)); });
-            }
-            else {
+                metadata[prop] = propValue.filter(function (value) {
+                    return !removeObjects.has(_propHashKey(prop, value, references));
+                });
+            } else {
                 if (removeObjects.has(_propHashKey(prop, propValue, references))) {
@@ -398,4 +525,5 @@ metadata[prop] = undefined;
         };
+
         for (var prop in metadata) {
-            _loop_2(prop);
+            _loop2(prop);
         }
@@ -406,7 +534,6 @@ }
             var addValue = add[prop];
-            var propValue = metadata[prop];
-            if (propValue != null && propValue instanceof Array) {
-                metadata[prop] = propValue.concat(addValue);
-            }
-            else {
+            var _propValue = metadata[prop];
+            if (_propValue != null && _propValue instanceof Array) {
+                metadata[prop] = _propValue.concat(addValue);
+            } else {
                 metadata[prop] = addValue;
@@ -422,3 +549,3 @@ }
     function _propHashKey(propName, propValue, references) {
-        var replacer = function (key, value) {
+        var replacer = function replacer(key, value) {
             if (typeof value === 'function') {
@@ -429,3 +556,3 @@ value = _serializeReference(value, references);
         };
-        return propName + ":" + JSON.stringify(propValue, replacer);
+        return propName + ':' + JSON.stringify(propValue, replacer);
     }
@@ -435,3 +562,3 @@ function _serializeReference(ref, references) {
         if (!id) {
-            id = "" + stringify(ref) + _nextReferenceId++;
+            id = '' + stringify(ref) + _nextReferenceId++;
             references.set(ref, id);
@@ -462,21 +589,30 @@ }
 
-    var TestingCompilerFactoryImpl = (function () {
+    var TestingCompilerFactoryImpl = function () {
         function TestingCompilerFactoryImpl(_compilerFactory) {
+            _classCallCheck(this, TestingCompilerFactoryImpl);
+
             this._compilerFactory = _compilerFactory;
         }
-        TestingCompilerFactoryImpl.prototype.createTestingCompiler = function (options) {
-            var compiler = this._compilerFactory.createCompiler(options);
-            return new TestingCompilerImpl(compiler, compiler.injector.get(MockDirectiveResolver), compiler.injector.get(MockPipeResolver), compiler.injector.get(MockNgModuleResolver));
-        };
+
+        _createClass(TestingCompilerFactoryImpl, [{
+            key: 'createTestingCompiler',
+            value: function createTestingCompiler(options) {
+                var compiler = this._compilerFactory.createCompiler(options);
+                return new TestingCompilerImpl(compiler, compiler.injector.get(MockDirectiveResolver), compiler.injector.get(MockPipeResolver), compiler.injector.get(MockNgModuleResolver));
+            }
+        }]);
+
         return TestingCompilerFactoryImpl;
-    }());
-    TestingCompilerFactoryImpl.decorators = [
-        { type: _angular_core.Injectable },
-    ];
+    }();
+
+    TestingCompilerFactoryImpl.decorators = [{ type: _core.Injectable }];
     /** @nocollapse */
-    TestingCompilerFactoryImpl.ctorParameters = function () { return [
-        { type: _angular_core.CompilerFactory, },
-    ]; };
-    var TestingCompilerImpl = (function () {
+    TestingCompilerFactoryImpl.ctorParameters = function () {
+        return [{ type: _core.CompilerFactory }];
+    };
+
+    var TestingCompilerImpl = function () {
         function TestingCompilerImpl(_compiler, _directiveResolver, _pipeResolver, _moduleResolver) {
+            _classCallCheck(this, TestingCompilerImpl);
+
             this._compiler = _compiler;
@@ -488,42 +624,72 @@ this._directiveResolver = _directiveResolver;
         }
-        Object.defineProperty(TestingCompilerImpl.prototype, "injector", {
-            get: function () { return this._compiler.injector; },
-            enumerable: true,
-            configurable: true
-        });
-        TestingCompilerImpl.prototype.compileModuleSync = function (moduleType) {
-            return this._compiler.compileModuleSync(moduleType);
-        };
-        TestingCompilerImpl.prototype.compileModuleAsync = function (moduleType) {
-            return this._compiler.compileModuleAsync(moduleType);
-        };
-        TestingCompilerImpl.prototype.compileModuleAndAllComponentsSync = function (moduleType) {
-            return this._compiler.compileModuleAndAllComponentsSync(moduleType);
-        };
-        TestingCompilerImpl.prototype.compileModuleAndAllComponentsAsync = function (moduleType) {
-            return this._compiler.compileModuleAndAllComponentsAsync(moduleType);
-        };
-        TestingCompilerImpl.prototype.getNgContentSelectors = function (component) {
-            return this._compiler.getNgContentSelectors(component);
-        };
-        TestingCompilerImpl.prototype.overrideModule = function (ngModule, override) {
-            var oldMetadata = this._moduleResolver.resolve(ngModule, false);
-            this._moduleResolver.setNgModule(ngModule, this._overrider.overrideMetadata(_angular_core.NgModule, oldMetadata, override));
-        };
-        TestingCompilerImpl.prototype.overrideDirective = function (directive, override) {
-            var oldMetadata = this._directiveResolver.resolve(directive, false);
-            this._directiveResolver.setDirective(directive, this._overrider.overrideMetadata(_angular_core.Directive, oldMetadata, override));
-        };
-        TestingCompilerImpl.prototype.overrideComponent = function (component, override) {
-            var oldMetadata = this._directiveResolver.resolve(component, false);
-            this._directiveResolver.setDirective(component, this._overrider.overrideMetadata(_angular_core.Component, oldMetadata, override));
-        };
-        TestingCompilerImpl.prototype.overridePipe = function (pipe, override) {
-            var oldMetadata = this._pipeResolver.resolve(pipe, false);
-            this._pipeResolver.setPipe(pipe, this._overrider.overrideMetadata(_angular_core.Pipe, oldMetadata, override));
-        };
-        TestingCompilerImpl.prototype.clearCache = function () { this._compiler.clearCache(); };
-        TestingCompilerImpl.prototype.clearCacheFor = function (type) { this._compiler.clearCacheFor(type); };
+
+        _createClass(TestingCompilerImpl, [{
+            key: 'compileModuleSync',
+            value: function compileModuleSync(moduleType) {
+                return this._compiler.compileModuleSync(moduleType);
+            }
+        }, {
+            key: 'compileModuleAsync',
+            value: function compileModuleAsync(moduleType) {
+                return this._compiler.compileModuleAsync(moduleType);
+            }
+        }, {
+            key: 'compileModuleAndAllComponentsSync',
+            value: function compileModuleAndAllComponentsSync(moduleType) {
+                return this._compiler.compileModuleAndAllComponentsSync(moduleType);
+            }
+        }, {
+            key: 'compileModuleAndAllComponentsAsync',
+            value: function compileModuleAndAllComponentsAsync(moduleType) {
+                return this._compiler.compileModuleAndAllComponentsAsync(moduleType);
+            }
+        }, {
+            key: 'getNgContentSelectors',
+            value: function getNgContentSelectors(component) {
+                return this._compiler.getNgContentSelectors(component);
+            }
+        }, {
+            key: 'overrideModule',
+            value: function overrideModule(ngModule, override) {
+                var oldMetadata = this._moduleResolver.resolve(ngModule, false);
+                this._moduleResolver.setNgModule(ngModule, this._overrider.overrideMetadata(_core.NgModule, oldMetadata, override));
+            }
+        }, {
+            key: 'overrideDirective',
+            value: function overrideDirective(directive, override) {
+                var oldMetadata = this._directiveResolver.resolve(directive, false);
+                this._directiveResolver.setDirective(directive, this._overrider.overrideMetadata(_core.Directive, oldMetadata, override));
+            }
+        }, {
+            key: 'overrideComponent',
+            value: function overrideComponent(component, override) {
+                var oldMetadata = this._directiveResolver.resolve(component, false);
+                this._directiveResolver.setDirective(component, this._overrider.overrideMetadata(_core.Component, oldMetadata, override));
+            }
+        }, {
+            key: 'overridePipe',
+            value: function overridePipe(pipe, override) {
+                var oldMetadata = this._pipeResolver.resolve(pipe, false);
+                this._pipeResolver.setPipe(pipe, this._overrider.overrideMetadata(_core.Pipe, oldMetadata, override));
+            }
+        }, {
+            key: 'clearCache',
+            value: function clearCache() {
+                this._compiler.clearCache();
+            }
+        }, {
+            key: 'clearCacheFor',
+            value: function clearCacheFor(type) {
+                this._compiler.clearCacheFor(type);
+            }
+        }, {
+            key: 'injector',
+            get: function get() {
+                return this._compiler.injector;
+            }
+        }]);
+
         return TestingCompilerImpl;
-    }());
+    }();
+
     /**
@@ -534,19 +700,9 @@ * Platform for dynamic tests
      */
-    var platformCoreDynamicTesting = _angular_core.createPlatformFactory(_angular_compiler.platformCoreDynamic, 'coreDynamicTesting', [
-        {
-            provide: _angular_core.COMPILER_OPTIONS,
-            useValue: {
-                providers: [
-                    MockPipeResolver,
-                    { provide: _angular_compiler.PipeResolver, useExisting: MockPipeResolver },
-                    MockDirectiveResolver,
-                    { provide: _angular_compiler.DirectiveResolver, useExisting: MockDirectiveResolver },
-                    MockNgModuleResolver,
-                    { provide: _angular_compiler.NgModuleResolver, useExisting: MockNgModuleResolver },
-                ]
-            },
-            multi: true
+    var platformCoreDynamicTesting = (0, _core.createPlatformFactory)(_compiler2.platformCoreDynamic, 'coreDynamicTesting', [{
+        provide: _core.COMPILER_OPTIONS,
+        useValue: {
+            providers: [MockPipeResolver, { provide: _compiler2.PipeResolver, useExisting: MockPipeResolver }, MockDirectiveResolver, { provide: _compiler2.DirectiveResolver, useExisting: MockDirectiveResolver }, MockNgModuleResolver, { provide: _compiler2.NgModuleResolver, useExisting: MockNgModuleResolver }]
         },
-        { provide: TestingCompilerFactory, useClass: TestingCompilerFactoryImpl }
-    ]);
+        multi: true
+    }, { provide: _testing.ɵTestingCompilerFactory, useClass: TestingCompilerFactoryImpl }]);
 
@@ -560,3 +716,2 @@ exports.TestingCompilerFactoryImpl = TestingCompilerFactoryImpl;
     exports.MockPipeResolver = MockPipeResolver;
-
-}));
+});

package.json

 {
   "name": "@angular/compiler",
-  "version": "4.0.0-beta.8",
+  "version": "4.0.0-rc.0",
   "description": "Angular - the compiler library",
-  "main": "bundles/compiler.umd.js",
-  "module": "index.js",
-  "typings": "index.d.ts",
+  "main": "./bundles/compiler.umd.js",
+  "module": "./@angular/compiler.es5.js",
+  "es2015": "./@angular/compiler.js",
+  "typings": "./typings/compiler.d.ts",
   "author": "angular",
   "license": "MIT",
   "peerDependencies": {
-    "@angular/core": "4.0.0-beta.8"
+    "@angular/core": "4.0.0-rc.0"
   },
@@ -13,0 +14,0 @@ "repository": {

testing/package.json

@@ -1,1 +0,1 @@
-{"main": "../bundles/compiler-testing.umd.js"}
+{"typings": "../typings/testing/index.d.ts", "main": "../bundles/compiler-testing.umd.js", "module": "../@angular/compiler/testing.es5.js", "es2015": "../@angular/compiler/testing.js"}

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Uses eval

Supply chain risk

Package uses eval() which is a dangerous function. This prevents the code from running in certain environments and increases the risk that the code may contain exploits or malicious behavior.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Worsened metrics

Total package byte prevSize

4370905

decreased by-30.42%

Number of package files

248

decreased by-49.18%

Lines of code

69867

decreased by-5.96%

Number of low supply chain risk alerts

4

increased by100%

Number of medium supply chain risk alerts

2

increased byInfinity%

No dependency changes