@sitecore-jss/sitecore-jss-angular 18.0.1 → 18.0.2

package/dist/__ivy_ngcc__/fesm2015/sitecore-jss-sitecore-jss-angular.js

@@ -1,1391 +0,0 @@
-import { Directive, ViewContainerRef, TemplateRef, Input, Renderer2, ElementRef, InjectionToken, Component, NgModuleFactory, Injectable, Injector, Compiler, Inject, EventEmitter, ComponentFactoryResolver, KeyValueDiffers, ChangeDetectorRef, Type, Output, ViewChild, ContentChild, ANALYZE_FOR_ENTRY_COMPONENTS, NgModule } from '@angular/core';
-import { __rest } from 'tslib';
-import { mediaApi, dataApi, isExperienceEditorActive } from '@sitecore-jss/sitecore-jss';
-import * as ɵngcc0 from '@angular/core';
-import * as ɵngcc1 from '@angular/router';
-import * as ɵngcc2 from '@angular/common';
-
-const _c0 = ["view"];
-function PlaceholderComponent_0_ng_template_0_Template(rf, ctx) { }
-function PlaceholderComponent_0_Template(rf, ctx) { if (rf & 1) {
-    ɵngcc0.ɵɵtemplate(0, PlaceholderComponent_0_ng_template_0_Template, 0, 0, "ng-template", 2);
-} if (rf & 2) {
-    const ctx_r0 = ɵngcc0.ɵɵnextContext();
-    ɵngcc0.ɵɵproperty("ngTemplateOutlet", ctx_r0.placeholderLoading == null ? null : ctx_r0.placeholderLoading.templateRef);
-} }
-function PlaceholderComponent_ng_template_1_Template(rf, ctx) { }
-function RenderComponentComponent_ng_template_0_Template(rf, ctx) { }
-export { dataApi, getChildPlaceholder, getFieldValue, isExperienceEditorActive, isServer, mediaApi, resetExperienceEditorChromes } from '@sitecore-jss/sitecore-jss';
-import { Router, ROUTES } from '@angular/router';
-import { Observable, throwError, from } from 'rxjs';
-import { takeWhile, catchError } from 'rxjs/operators';
-import { DatePipe, CommonModule } from '@angular/common';
-
-/**
- * File fields cannot be managed via the EE. We never output "editable."
- */
-class FileDirective {
-    constructor(viewContainer, templateRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-    }
-    ngOnChanges(changes) {
-        if (changes.field) {
-            if (!this.viewRef) {
-                this.viewContainer.clear();
-                this.viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-            }
-            this.updateView();
-        }
-    }
-    updateView() {
-        const field = this.field;
-        if (!field || (!field.value && !field.src)) {
-            return;
-        }
-        const file = field.src ? field : field.value;
-        this.viewRef.rootNodes.forEach((node) => {
-            node.href = file.src;
-            if (node.innerHTML === '') {
-                node.innerHTML = file.title || file.displayName;
-            }
-        });
-    }
-}
-FileDirective.ɵfac = function FileDirective_Factory(t) { return new (t || FileDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef)); };
-FileDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: FileDirective, selectors: [["", "scFile", ""]], inputs: { field: ["scFile", "field"] }, features: [ɵngcc0.ɵɵNgOnChangesFeature] });
-FileDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef }
-];
-FileDirective.propDecorators = {
-    field: [{ type: Input, args: ['scFile',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(FileDirective, [{
-        type: Directive,
-        args: [{ selector: '[scFile]' }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }]; }, { field: [{
-            type: Input,
-            args: ['scFile']
-        }] }); })();
-
-class ImageDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-        this.inlineRef = null;
-        this.editable = true;
-        this.urlParams = {};
-        this.attrs = {};
-    }
-    ngOnChanges(changes) {
-        if (changes.field || changes.editable || changes.urlParams || changes.attrs) {
-            this.viewContainer.clear();
-            if (this.inlineRef) {
-                this.inlineRef.remove();
-                this.inlineRef = null;
-            }
-            this.updateView();
-        }
-    }
-    updateView() {
-        const overrideAttrs = Object.assign(Object.assign({}, this.getElementAttrs()), this.attrs);
-        const media = this.field;
-        if (!media || (!media.editable && !media.value && !media.src)) {
-            return;
-        }
-        let attrs = {};
-        // we likely have an experience editor value, should be a string
-        if (this.editable && media.editable) {
-            const foundImg = mediaApi.findEditorImageTag(media.editable);
-            if (!foundImg) {
-                return this.renderInlineWrapper(media.editable);
-            }
-            attrs = this.getImageAttrs(foundImg.attrs, overrideAttrs, this.urlParams);
-            if (!attrs) {
-                return this.renderInlineWrapper(media.editable);
-            }
-            const tempImg = this.renderer.createElement('img');
-            Object.entries(attrs).forEach(([key, attrValue]) => tempImg.setAttribute(key, attrValue));
-            const editableMarkup = media.editable.replace(foundImg.imgTag, tempImg.outerHTML);
-            return this.renderInlineWrapper(editableMarkup);
-        }
-        // some wise-guy/gal is passing in a 'raw' image object value
-        const img = media.src ? media : media.value;
-        if (!img) {
-            return null;
-        }
-        attrs = this.getImageAttrs(img, overrideAttrs, this.urlParams);
-        if (attrs) {
-            this.renderTemplate(attrs);
-        }
-    }
-    getImageAttrs(fieldAttrs, parsedAttrs, imageParams) {
-        const combinedAttrs = Object.assign(Object.assign({}, fieldAttrs), parsedAttrs);
-        // eslint-disable-next-line prefer-const
-        let { src, srcSet } = combinedAttrs, otherAttrs = __rest(combinedAttrs, ["src", "srcSet"]);
-        if (!src) {
-            return null;
-        }
-        const newAttrs = Object.assign({}, otherAttrs);
-        // update image URL for jss handler and image rendering params
-        src = mediaApi.updateImageUrl(src, imageParams, this.mediaUrlPrefix);
-        if (srcSet) {
-            // replace with HTML-formatted srcset, including updated image URLs
-            newAttrs.srcSet = mediaApi.getSrcSet(src, srcSet, imageParams, this.mediaUrlPrefix);
-        }
-        else {
-            newAttrs.src = src;
-        }
-        return newAttrs;
-    }
-    renderTemplate(imageProps) {
-        const viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-        viewRef.rootNodes.forEach((node) => {
-            Object.entries(imageProps).forEach(([key, imgPropVal]) => this.renderer.setAttribute(node, key, imgPropVal));
-        });
-    }
-    getElementAttrs() {
-        const view = this.templateRef.createEmbeddedView(null);
-        const element = view.rootNodes[0];
-        if (!element) {
-            return {};
-        }
-        const attrs = {};
-        for (let i = 0; i < element.attributes.length; i++) {
-            const attr = element.attributes.item(i);
-            if (attr) {
-                attrs[attr.name] = attr.value;
-            }
-        }
-        return attrs;
-    }
-    renderInlineWrapper(editable) {
-        const span = this.renderer.createElement('span');
-        span.className = 'sc-image-wrapper';
-        span.innerHTML = editable;
-        const parentNode = this.renderer.parentNode(this.elementRef.nativeElement);
-        this.renderer.insertBefore(parentNode, span, this.elementRef.nativeElement);
-        parentNode.removeChild(this.elementRef.nativeElement);
-        this.inlineRef = span;
-    }
-}
-ImageDirective.ɵfac = function ImageDirective_Factory(t) { return new (t || ImageDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Renderer2), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef)); };
-ImageDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: ImageDirective, selectors: [["", "scImage", ""]], inputs: { editable: ["scImageEditable", "editable"], urlParams: ["scImageUrlParams", "urlParams"], attrs: ["scImageAttrs", "attrs"], field: ["scImage", "field"], mediaUrlPrefix: ["scImageMediaUrlPrefix", "mediaUrlPrefix"] }, features: [ɵngcc0.ɵɵNgOnChangesFeature] });
-ImageDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-ImageDirective.propDecorators = {
-    field: [{ type: Input, args: ['scImage',] }],
-    editable: [{ type: Input, args: ['scImageEditable',] }],
-    mediaUrlPrefix: [{ type: Input, args: ['scImageMediaUrlPrefix',] }],
-    urlParams: [{ type: Input, args: ['scImageUrlParams',] }],
-    attrs: [{ type: Input, args: ['scImageAttrs',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(ImageDirective, [{
-        type: Directive,
-        args: [{ selector: '[scImage]' }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.Renderer2 }, { type: ɵngcc0.ElementRef }]; }, { editable: [{
-            type: Input,
-            args: ['scImageEditable']
-        }], urlParams: [{
-            type: Input,
-            args: ['scImageUrlParams']
-        }], attrs: [{
-            type: Input,
-            args: ['scImageAttrs']
-        }], field: [{
-            type: Input,
-            args: ['scImage']
-        }], mediaUrlPrefix: [{
-            type: Input,
-            args: ['scImageMediaUrlPrefix']
-        }] }); })();
-
-class LinkDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-        this.inlineRef = null;
-        this.editable = true;
-        this.attrs = {};
-    }
-    ngOnChanges(changes) {
-        if (changes.field || changes.editable || changes.attrs) {
-            this.viewContainer.clear();
-            if (this.inlineRef) {
-                this.inlineRef.remove();
-                this.inlineRef = null;
-            }
-            this.updateView();
-        }
-    }
-    updateView() {
-        const field = this.field;
-        if (this.editable && field && field.editableFirstPart && field.editableLastPart) {
-            this.renderInlineWrapper(field.editableFirstPart, field.editableLastPart);
-        }
-        else if (field && (field.href || field.value)) {
-            const props = field.href ? field : field.value;
-            const linkText = field.text || field.value.text || field.href || field.value.href;
-            const mergedAttrs = Object.assign(Object.assign({}, props), this.attrs);
-            this.renderTemplate(mergedAttrs, linkText);
-        }
-    }
-    renderTemplate(props, linkText) {
-        const viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-        viewRef.rootNodes.forEach((node) => {
-            Object.entries(props).forEach(([key, propValue]) => {
-                if (key === 'href') {
-                    const isInvalidLink = !propValue || /^https?:\/\/$/.test(propValue);
-                    if (isInvalidLink) {
-                        if (!node.href) {
-                            return;
-                        }
-                        propValue = node.href;
-                    }
-                }
-                if (key === 'class' && node.className) {
-                    propValue += ` ${node.className}`;
-                }
-                this.renderer.setAttribute(node, key, propValue);
-            });
-            if (node.childNodes && node.childNodes.length === 0 && linkText) {
-                node.textContent = linkText;
-            }
-        });
-    }
-    renderInlineWrapper(editableFirstPart, editableLastPart) {
-        const span = this.renderer.createElement('span');
-        span.className = 'sc-link-wrapper';
-        span.innerHTML = editableFirstPart + editableLastPart;
-        // assign attributes from template to inline wrapper
-        const attrs = Object.assign(Object.assign({}, this.getElementAttrs()), this.attrs);
-        Object.entries(attrs).forEach(([key, attrValue]) => this.renderer.setAttribute(span, key, attrValue));
-        this.viewContainer.createEmbeddedView(this.templateRef);
-        const parentNode = this.renderer.parentNode(this.elementRef.nativeElement);
-        this.renderer.insertBefore(parentNode, span, this.elementRef.nativeElement);
-        this.inlineRef = span;
-    }
-    getElementAttrs() {
-        const view = this.templateRef.createEmbeddedView(null);
-        const element = view.rootNodes[0];
-        if (!element) {
-            return {};
-        }
-        const attrs = {};
-        for (let i = 0; i < element.attributes.length; i++) {
-            const attr = element.attributes.item(i);
-            if (attr) {
-                attrs[attr.name] = attr.value;
-            }
-        }
-        return attrs;
-    }
-}
-LinkDirective.ɵfac = function LinkDirective_Factory(t) { return new (t || LinkDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Renderer2), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef)); };
-LinkDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: LinkDirective, selectors: [["", "scLink", ""]], inputs: { editable: ["scLinkEditable", "editable"], attrs: ["scLinkAttrs", "attrs"], field: ["scLink", "field"] }, features: [ɵngcc0.ɵɵNgOnChangesFeature] });
-LinkDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-LinkDirective.propDecorators = {
-    editable: [{ type: Input, args: ['scLinkEditable',] }],
-    attrs: [{ type: Input, args: ['scLinkAttrs',] }],
-    field: [{ type: Input, args: ['scLink',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(LinkDirective, [{
-        type: Directive,
-        args: [{ selector: '[scLink]' }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.Renderer2 }, { type: ɵngcc0.ElementRef }]; }, { editable: [{
-            type: Input,
-            args: ['scLinkEditable']
-        }], attrs: [{
-            type: Input,
-            args: ['scLinkAttrs']
-        }], field: [{
-            type: Input,
-            args: ['scLink']
-        }] }); })();
-
-class RouterLinkDirective extends LinkDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef, router) {
-        super(viewContainer, templateRef, renderer, elementRef);
-        this.router = router;
-        this.editable = true;
-        this.attrs = {};
-    }
-    renderTemplate(props, linkText) {
-        const viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-        viewRef.rootNodes.forEach((node) => {
-            Object.entries(props).forEach(([key, propValue]) => {
-                this.renderer.setAttribute(node, key, propValue);
-                if (key === 'href') {
-                    this.renderer.listen(node, 'click', (event) => {
-                        this.router.navigate([propValue]);
-                        event.preventDefault();
-                    });
-                }
-            });
-            if (node.childNodes && node.childNodes.length === 0 && linkText) {
-                node.textContent = linkText;
-            }
-        });
-    }
-}
-RouterLinkDirective.ɵfac = function RouterLinkDirective_Factory(t) { return new (t || RouterLinkDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Renderer2), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Router)); };
-RouterLinkDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: RouterLinkDirective, selectors: [["", "scRouterLink", ""]], inputs: { editable: ["scRouterLinkEditable", "editable"], attrs: ["scRouterLinkAttrs", "attrs"], field: ["scRouterLink", "field"] }, features: [ɵngcc0.ɵɵInheritDefinitionFeature] });
-RouterLinkDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef },
-    { type: Router }
-];
-RouterLinkDirective.propDecorators = {
-    editable: [{ type: Input, args: ['scRouterLinkEditable',] }],
-    attrs: [{ type: Input, args: ['scRouterLinkAttrs',] }],
-    field: [{ type: Input, args: ['scRouterLink',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(RouterLinkDirective, [{
-        type: Directive,
-        args: [{ selector: '[scRouterLink]' }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.Renderer2 }, { type: ɵngcc0.ElementRef }, { type: ɵngcc1.Router }]; }, { editable: [{
-            type: Input,
-            args: ['scRouterLinkEditable']
-        }], attrs: [{
-            type: Input,
-            args: ['scRouterLinkAttrs']
-        }], field: [{
-            type: Input,
-            args: ['scRouterLink']
-        }] }); })();
-
-class GenericLinkDirective extends LinkDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef, router) {
-        super(viewContainer, templateRef, renderer, elementRef);
-        this.router = router;
-        this.editable = true;
-        this.attrs = {};
-    }
-    renderTemplate(props, linkText) {
-        const viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-        viewRef.rootNodes.forEach((node) => {
-            Object.entries(props).forEach(([key, propValue]) => {
-                if (key === 'href' && !this.isAbsoluteUrl(propValue)) {
-                    const urlTree = this.router.createUrlTree([propValue], this.extras);
-                    this.renderer.setAttribute(node, key, this.router.serializeUrl(urlTree));
-                    this.renderer.listen(node, 'click', (event) => {
-                        this.router.navigate([propValue], this.extras);
-                        event.preventDefault();
-                    });
-                }
-                else {
-                    this.renderer.setAttribute(node, key, propValue);
-                }
-            });
-            if (node.childNodes && node.childNodes.length === 0 && linkText) {
-                node.textContent = linkText;
-            }
-        });
-    }
-    isAbsoluteUrl(url) {
-        if (url === null) {
-            return false;
-        }
-        if (typeof url !== 'string') {
-            throw new TypeError('Expected a string');
-        }
-        return /^[a-z][a-z0-9+.-]*:/.test(url);
-    }
-}
-GenericLinkDirective.ɵfac = function GenericLinkDirective_Factory(t) { return new (t || GenericLinkDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Renderer2), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc1.Router)); };
-GenericLinkDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: GenericLinkDirective, selectors: [["", "scGenericLink", ""]], inputs: { editable: ["scGenericLinkEditable", "editable"], attrs: ["scGenericLinkAttrs", "attrs"], field: ["scGenericLink", "field"], extras: ["scGenericLinkExtras", "extras"] }, features: [ɵngcc0.ɵɵInheritDefinitionFeature] });
-GenericLinkDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef },
-    { type: Router }
-];
-GenericLinkDirective.propDecorators = {
-    editable: [{ type: Input, args: ['scGenericLinkEditable',] }],
-    attrs: [{ type: Input, args: ['scGenericLinkAttrs',] }],
-    field: [{ type: Input, args: ['scGenericLink',] }],
-    extras: [{ type: Input, args: ['scGenericLinkExtras',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(GenericLinkDirective, [{
-        type: Directive,
-        args: [{ selector: '[scGenericLink]' }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc0.Renderer2 }, { type: ɵngcc0.ElementRef }, { type: ɵngcc1.Router }]; }, { editable: [{
-            type: Input,
-            args: ['scGenericLinkEditable']
-        }], attrs: [{
-            type: Input,
-            args: ['scGenericLinkAttrs']
-        }], field: [{
-            type: Input,
-            args: ['scGenericLink']
-        }], extras: [{
-            type: Input,
-            args: ['scGenericLinkExtras']
-        }] }); })();
-
-/** Registers a statically loaded component */
-class ComponentNameAndType {
-}
-/**
- * @param {any} object
- */
-function instanceOfComponentNameAndType(object) {
-    return 'type' in object;
-}
-/**
- * @param {any} object
- */
-function instanceOfComponentNameAndModule(object) {
-    return 'module' in object;
-}
-const PLACEHOLDER_COMPONENTS = new InjectionToken('Sc.placeholder.components');
-const PLACEHOLDER_LAZY_COMPONENTS = new InjectionToken('Sc.placeholder.lazyComponents');
-const PLACEHOLDER_MISSING_COMPONENT_COMPONENT = new InjectionToken('Sc.placeholder.missingComponentComponent');
-const DYNAMIC_COMPONENT = new InjectionToken('Sc.placeholder.dynamicComponent');
-
-class RawComponent {
-    constructor(renderer, elementRef) {
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-    }
-    ngOnInit() {
-        const el = this.renderer.createElement(this.rendering.name);
-        const contents = this.renderer.createText(this.rendering.contents || '');
-        const attributes = this.rendering.attributes;
-        for (const attr in attributes) {
-            // eslint-disable-next-line no-prototype-builtins
-            if (attributes.hasOwnProperty(attr)) {
-                const value = attributes[attr];
-                this.renderer.setAttribute(el, attr, value || '');
-            }
-        }
-        this.renderer.appendChild(el, contents);
-        const parentNode = this.renderer.parentNode(this.elementRef.nativeElement);
-        this.renderer.insertBefore(parentNode, el, this.elementRef.nativeElement);
-        parentNode.removeChild(this.elementRef.nativeElement);
-    }
-}
-RawComponent.ɵfac = function RawComponent_Factory(t) { return new (t || RawComponent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Renderer2), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef)); };
-RawComponent.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: RawComponent, selectors: [["sc-raw"]], inputs: { rendering: "rendering" }, decls: 0, vars: 0, template: function RawComponent_Template(rf, ctx) { }, encapsulation: 2 });
-RawComponent.ctorParameters = () => [
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-RawComponent.propDecorators = {
-    rendering: [{ type: Input }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(RawComponent, [{
-        type: Component,
-        args: [{
-                selector: 'sc-raw',
-                template: ''
-            }]
-    }], function () { return [{ type: ɵngcc0.Renderer2 }, { type: ɵngcc0.ElementRef }]; }, { rendering: [{
-            type: Input
-        }] }); })();
-
-/**
- * @param {HtmlElementRendering | ComponentRendering} rendering
- */
-function isRawRendering(rendering) {
-    return (!rendering.componentName &&
-        rendering.name !== undefined);
-}
-
-class JssComponentFactoryService {
-    constructor(injector, compiler, components, lazyComponents) {
-        this.injector = injector;
-        this.compiler = compiler;
-        this.components = components;
-        this.lazyComponents = lazyComponents;
-        this.componentMap = new Map();
-        this.lazyComponentMap = new Map();
-        this.components.forEach((c) => this.componentMap.set(c.name, c.type));
-        if (this.lazyComponents) {
-            this.lazyComponents.forEach((c) => this.lazyComponentMap.set(c.path, c));
-        }
-    }
-    loadModuleFactory(lazyComponent) {
-        return lazyComponent.loadChildren().then((loaded) => {
-            if (loaded instanceof NgModuleFactory) {
-                return loaded;
-            }
-            else {
-                return this.compiler.compileModuleAsync(loaded);
-            }
-        });
-    }
-    getComponent(component) {
-        const loadedComponent = this.componentMap.get(component.componentName);
-        if (loadedComponent) {
-            return Promise.resolve({
-                componentDefinition: component,
-                componentImplementation: this.componentMap.get(component.componentName),
-            });
-        }
-        const lazyComponent = this.lazyComponentMap.get(component.componentName);
-        if (lazyComponent) {
-            return this.loadModuleFactory(lazyComponent).then((ngModuleFactory) => {
-                let componentType = null;
-                const moduleRef = ngModuleFactory.create(this.injector);
-                const dynamicComponentType = moduleRef.injector.get(DYNAMIC_COMPONENT);
-                if (!dynamicComponentType) {
-                    throw new Error(`JssComponentFactoryService: Lazy load module for component "${lazyComponent.path}" missing DYNAMIC_COMPONENT provider. Missing JssModule.forChild()?`);
-                }
-                if (component.componentName in dynamicComponentType) {
-                    componentType = dynamicComponentType[component.componentName];
-                }
-                else {
-                    if (typeof dynamicComponentType === 'function') {
-                        componentType = dynamicComponentType;
-                    }
-                    else {
-                        throw new Error(`JssComponentFactoryService: Lazy load module for component "${lazyComponent.path}" missing DYNAMIC_COMPONENT provider. Missing JssModule.forChild()?`);
-                    }
-                }
-                return {
-                    componentDefinition: component,
-                    componentImplementation: componentType,
-                    componentFactory: moduleRef.componentFactoryResolver.resolveComponentFactory(componentType),
-                };
-            });
-        }
-        return Promise.resolve({
-            componentDefinition: component,
-        });
-    }
-    getComponents(components) {
-        // acquire all components and keep them in order while handling their potential async-ness
-        return Promise.all(components.map((component) => isRawRendering(component) ? this.getRawComponent(component) : this.getComponent(component)));
-    }
-    getRawComponent(component) {
-        return Promise.resolve({
-            componentImplementation: RawComponent,
-            componentDefinition: component,
-        });
-    }
-}
-JssComponentFactoryService.ɵfac = function JssComponentFactoryService_Factory(t) { return new (t || JssComponentFactoryService)(ɵngcc0.ɵɵinject(ɵngcc0.Injector), ɵngcc0.ɵɵinject(ɵngcc0.Compiler), ɵngcc0.ɵɵinject(PLACEHOLDER_COMPONENTS), ɵngcc0.ɵɵinject(PLACEHOLDER_LAZY_COMPONENTS)); };
-JssComponentFactoryService.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: JssComponentFactoryService, factory: JssComponentFactoryService.ɵfac });
-JssComponentFactoryService.ctorParameters = () => [
-    { type: Injector },
-    { type: Compiler },
-    { type: Array, decorators: [{ type: Inject, args: [PLACEHOLDER_COMPONENTS,] }] },
-    { type: Array, decorators: [{ type: Inject, args: [PLACEHOLDER_LAZY_COMPONENTS,] }] }
-];
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(JssComponentFactoryService, [{
-        type: Injectable
-    }], function () { return [{ type: ɵngcc0.Injector }, { type: ɵngcc0.Compiler }, { type: Array, decorators: [{
-                type: Inject,
-                args: [PLACEHOLDER_COMPONENTS]
-            }] }, { type: Array, decorators: [{
-                type: Inject,
-                args: [PLACEHOLDER_LAZY_COMPONENTS]
-            }] }]; }, null); })();
-
-class PlaceholderLoadingDirective {
-    constructor(templateRef) {
-        this.templateRef = templateRef;
-    }
-}
-PlaceholderLoadingDirective.ɵfac = function PlaceholderLoadingDirective_Factory(t) { return new (t || PlaceholderLoadingDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef)); };
-PlaceholderLoadingDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: PlaceholderLoadingDirective, selectors: [["", "scPlaceholderLoading", ""]] });
-PlaceholderLoadingDirective.ctorParameters = () => [
-    { type: TemplateRef }
-];
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(PlaceholderLoadingDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[scPlaceholderLoading]'
-            }]
-    }], function () { return [{ type: ɵngcc0.TemplateRef }]; }, null); })();
-
-class RenderEachDirective {
-    constructor(templateRef) {
-        this.templateRef = templateRef;
-    }
-}
-RenderEachDirective.ɵfac = function RenderEachDirective_Factory(t) { return new (t || RenderEachDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef)); };
-RenderEachDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: RenderEachDirective, selectors: [["", "renderEach", ""]] });
-RenderEachDirective.ctorParameters = () => [
-    { type: TemplateRef }
-];
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(RenderEachDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[renderEach]'
-            }]
-    }], function () { return [{ type: ɵngcc0.TemplateRef }]; }, null); })();
-
-class RenderEmptyDirective {
-    constructor(templateRef) {
-        this.templateRef = templateRef;
-    }
-}
-RenderEmptyDirective.ɵfac = function RenderEmptyDirective_Factory(t) { return new (t || RenderEmptyDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef)); };
-RenderEmptyDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: RenderEmptyDirective, selectors: [["", "renderEmpty", ""]] });
-RenderEmptyDirective.ctorParameters = () => [
-    { type: TemplateRef }
-];
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(RenderEmptyDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[renderEmpty]'
-            }]
-    }], function () { return [{ type: ɵngcc0.TemplateRef }]; }, null); })();
-
-/* eslint-disable @angular-eslint/no-conflicting-lifecycle */
-/**
- * @param {ComponentRendering} rendering
- * @param {string} name
- */
-function getPlaceholder(rendering, name) {
-    if (rendering && rendering.placeholders && Object.keys(rendering.placeholders).length > 0) {
-        return rendering.placeholders[name];
-    }
-    return null;
-}
-class PlaceholderComponent {
-    constructor(componentFactoryResolver, differs, componentFactory, changeDetectorRef, elementRef, renderer, missingComponentComponent) {
-        this.componentFactoryResolver = componentFactoryResolver;
-        this.differs = differs;
-        this.componentFactory = componentFactory;
-        this.changeDetectorRef = changeDetectorRef;
-        this.elementRef = elementRef;
-        this.renderer = renderer;
-        this.missingComponentComponent = missingComponentComponent;
-        this._componentInstances = [];
-        this.destroyed = false;
-        this.parentStyleAttribute = '';
-        this.isLoading = true;
-        this.loaded = new EventEmitter();
-    }
-    set inputs(value) {
-        this._inputs = value;
-        if (!this._differ && value) {
-            this._differ = this.differs.find(value).create();
-        }
-    }
-    ngOnInit() {
-        // just to ensure the element exists
-        const elem = this.elementRef.nativeElement;
-        if (elem) {
-            const attributes = elem.attributes;
-            for (let i = 0; i < attributes.length; i++) {
-                const attr = attributes.item(i);
-                if (attr && attr.name.indexOf('_ngcontent') !== -1) {
-                    this.parentStyleAttribute = attr.name;
-                }
-            }
-        }
-    }
-    ngOnDestroy() {
-        this.destroyed = true;
-        this._componentInstances = [];
-    }
-    ngOnChanges(changes) {
-        if (changes.rendering || changes.renderings) {
-            this._render();
-        }
-    }
-    ngDoCheck() {
-        if (!this._differ || !this._inputs || this._componentInstances.length === 0) {
-            return;
-        }
-        const changes = this._differ.diff(this._inputs);
-        if (!changes) {
-            return;
-        }
-        const updates = {};
-        changes.forEachRemovedItem((change) => (updates[change.key] = null));
-        changes.forEachAddedItem((change) => (updates[change.key] = change.currentValue));
-        changes.forEachChangedItem((change) => (updates[change.key] = change.currentValue));
-        this._componentInstances.forEach((componentInstance) => this._setComponentInputs(componentInstance, updates));
-    }
-    _setComponentInputs(componentInstance, inputs) {
-        Object.entries(inputs).forEach(([input, inputValue]) => (componentInstance[input] = inputValue));
-    }
-    _subscribeComponentOutputs(componentInstance, outputs) {
-        Object.keys(outputs)
-            .filter((output) => componentInstance[output] && componentInstance[output] instanceof Observable)
-            .forEach((output) => componentInstance[output]
-            .pipe(takeWhile(() => !this.destroyed))
-            .subscribe(outputs[output]));
-    }
-    _render() {
-        this._componentInstances = [];
-        this.view.clear();
-        if (!this.rendering && !this.renderings) {
-            return;
-        }
-        if (!this.name && !this.renderings) {
-            console.warn('Placeholder name was not specified, and explicit renderings array was not passed. Placeholder requires either name and rendering, or renderings.');
-            this.isLoading = false;
-            return;
-        }
-        const placeholder = this.renderings || getPlaceholder(this.rendering, this.name || '');
-        if (!placeholder) {
-            console.warn(`Placeholder '${this.name}' was not found in the current rendering data`, JSON.stringify(this.rendering, null, 2));
-            this.isLoading = false;
-            return;
-        }
-        // if the placeholder is empty (contains only raw renderings), then we may need to use the empty template if it's defined
-        const placeholderIsEmpty = placeholder.every((rendering) => isRawRendering(rendering));
-        if (this.renderEmptyTemplate && placeholderIsEmpty) {
-            this.view.createEmbeddedView(this.renderEmptyTemplate.templateRef, {
-                renderings: placeholder,
-            });
-            this.isLoading = false;
-        }
-        else {
-            this.componentFactory
-                .getComponents(placeholder)
-                .then((components) => components.forEach((rendering, index) => {
-                if (this.renderEachTemplate && !isRawRendering(rendering.componentDefinition)) {
-                    this._renderTemplatedComponent(rendering.componentDefinition, index);
-                }
-                else {
-                    this._renderEmbeddedComponent(rendering, index);
-                }
-                this.isLoading = false;
-            }))
-                .then(() => {
-                this.changeDetectorRef.markForCheck();
-                this.loaded.emit(this.name);
-            });
-        }
-    }
-    _renderTemplatedComponent(rendering, index) {
-        // the render-each template takes care of all component mapping etc
-        // generally using <sc-render-component> which is about like _renderEmbeddedComponent()
-        // as a separate component
-        this.view.createEmbeddedView(this.renderEachTemplate.templateRef, {
-            rendering,
-            index,
-        });
-    }
-    _renderEmbeddedComponent(rendering, index) {
-        if (!rendering.componentImplementation) {
-            const componentName = rendering.componentDefinition.componentName;
-            console.error(`Placeholder ${this.name} contains unknown component ${componentName}.`, `Ensure component is mapped, like:
-        JssModule.withComponents([
-          { name: '${componentName}', type: ${componentName}Component }
-        ])`);
-            rendering.componentImplementation = this.missingComponentComponent;
-        }
-        const componentFactory = rendering.componentFactory ||
-            this.componentFactoryResolver.resolveComponentFactory(rendering.componentImplementation);
-        // apply the parent style attribute _ngcontent
-        // work-around for https://github.com/angular/angular/issues/12215
-        const createdComponentRef = this.view.createComponent(componentFactory, index);
-        if (this.parentStyleAttribute) {
-            this.renderer.setAttribute(createdComponentRef.location.nativeElement, this.parentStyleAttribute, '');
-        }
-        const componentInstance = createdComponentRef.instance;
-        componentInstance.rendering = rendering.componentDefinition;
-        if (this._inputs) {
-            this._setComponentInputs(componentInstance, this._inputs);
-        }
-        if (this.outputs) {
-            this._subscribeComponentOutputs(componentInstance, this.outputs);
-        }
-        this._componentInstances.push(componentInstance);
-    }
-}
-PlaceholderComponent.ɵfac = function PlaceholderComponent_Factory(t) { return new (t || PlaceholderComponent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.KeyValueDiffers), ɵngcc0.ɵɵdirectiveInject(JssComponentFactoryService), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ChangeDetectorRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ElementRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.Renderer2), ɵngcc0.ɵɵdirectiveInject(PLACEHOLDER_MISSING_COMPONENT_COMPONENT)); };
-PlaceholderComponent.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: PlaceholderComponent, selectors: [["sc-placeholder"], ["", "sc-placeholder", ""]], contentQueries: function PlaceholderComponent_ContentQueries(rf, ctx, dirIndex) { if (rf & 1) {
-        ɵngcc0.ɵɵcontentQuery(dirIndex, RenderEachDirective, 3);
-        ɵngcc0.ɵɵcontentQuery(dirIndex, RenderEmptyDirective, 3);
-        ɵngcc0.ɵɵcontentQuery(dirIndex, PlaceholderLoadingDirective, 3);
-    } if (rf & 2) {
-        let _t;
-        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.renderEachTemplate = _t.first);
-        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.renderEmptyTemplate = _t.first);
-        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.placeholderLoading = _t.first);
-    } }, viewQuery: function PlaceholderComponent_Query(rf, ctx) { if (rf & 1) {
-        ɵngcc0.ɵɵviewQuery(_c0, 3, ViewContainerRef);
-    } if (rf & 2) {
-        let _t;
-        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.view = _t.first);
-    } }, inputs: { inputs: "inputs", name: "name", rendering: "rendering", renderings: "renderings", outputs: "outputs" }, outputs: { loaded: "loaded" }, features: [ɵngcc0.ɵɵNgOnChangesFeature], decls: 3, vars: 1, consts: [[4, "ngIf"], ["view", ""], [3, "ngTemplateOutlet"]], template: function PlaceholderComponent_Template(rf, ctx) { if (rf & 1) {
-        ɵngcc0.ɵɵtemplate(0, PlaceholderComponent_0_Template, 1, 1, undefined, 0);
-        ɵngcc0.ɵɵtemplate(1, PlaceholderComponent_ng_template_1_Template, 0, 0, "ng-template", null, 1, ɵngcc0.ɵɵtemplateRefExtractor);
-    } if (rf & 2) {
-        ɵngcc0.ɵɵproperty("ngIf", ctx.isLoading);
-    } }, directives: [ɵngcc2.NgIf, ɵngcc2.NgTemplateOutlet], encapsulation: 2 });
-PlaceholderComponent.ctorParameters = () => [
-    { type: ComponentFactoryResolver },
-    { type: KeyValueDiffers },
-    { type: JssComponentFactoryService },
-    { type: ChangeDetectorRef },
-    { type: ElementRef },
-    { type: Renderer2 },
-    { type: Type, decorators: [{ type: Inject, args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT,] }] }
-];
-PlaceholderComponent.propDecorators = {
-    name: [{ type: Input }],
-    rendering: [{ type: Input }],
-    renderings: [{ type: Input }],
-    outputs: [{ type: Input }],
-    loaded: [{ type: Output }],
-    view: [{ type: ViewChild, args: ['view', { read: ViewContainerRef, static: true },] }],
-    renderEachTemplate: [{ type: ContentChild, args: [RenderEachDirective, { static: true },] }],
-    renderEmptyTemplate: [{ type: ContentChild, args: [RenderEmptyDirective, { static: true },] }],
-    placeholderLoading: [{ type: ContentChild, args: [PlaceholderLoadingDirective, { static: true },] }],
-    inputs: [{ type: Input }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(PlaceholderComponent, [{
-        type: Component,
-        args: [{
-                selector: 'sc-placeholder,[sc-placeholder]',
-                template: `
-    <ng-template
-      *ngIf="isLoading"
-      [ngTemplateOutlet]="placeholderLoading?.templateRef"
-    ></ng-template>
-    <ng-template #view></ng-template>
-  `
-            }]
-    }], function () { return [{ type: ɵngcc0.ComponentFactoryResolver }, { type: ɵngcc0.KeyValueDiffers }, { type: JssComponentFactoryService }, { type: ɵngcc0.ChangeDetectorRef }, { type: ɵngcc0.ElementRef }, { type: ɵngcc0.Renderer2 }, { type: ɵngcc0.Type, decorators: [{
-                type: Inject,
-                args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT]
-            }] }]; }, { loaded: [{
-            type: Output
-        }], inputs: [{
-            type: Input
-        }], name: [{
-            type: Input
-        }], rendering: [{
-            type: Input
-        }], renderings: [{
-            type: Input
-        }], outputs: [{
-            type: Input
-        }], view: [{
-            type: ViewChild,
-            args: ['view', { read: ViewContainerRef, static: true }]
-        }], renderEachTemplate: [{
-            type: ContentChild,
-            args: [RenderEachDirective, { static: true }]
-        }], renderEmptyTemplate: [{
-            type: ContentChild,
-            args: [RenderEmptyDirective, { static: true }]
-        }], placeholderLoading: [{
-            type: ContentChild,
-            args: [PlaceholderLoadingDirective, { static: true }]
-        }] }); })();
-
-class RichTextDirective {
-    constructor(viewContainer, templateRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.editable = true;
-    }
-    ngOnChanges(changes) {
-        if (changes.field || changes.editable) {
-            if (!this.viewRef) {
-                this.viewContainer.clear();
-                this.viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-            }
-            this.updateView();
-        }
-    }
-    updateView() {
-        const field = this.field;
-        if (!field || (!field.editable && !field.value)) {
-            return;
-        }
-        const html = field.editable && this.editable ? field.editable : field.value;
-        this.viewRef.rootNodes.forEach((node) => {
-            node.innerHTML = html;
-        });
-    }
-}
-RichTextDirective.ɵfac = function RichTextDirective_Factory(t) { return new (t || RichTextDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef)); };
-RichTextDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: RichTextDirective, selectors: [["", "scRichText", ""]], inputs: { editable: ["scRichTextEditable", "editable"], field: ["scRichText", "field"] }, features: [ɵngcc0.ɵɵNgOnChangesFeature] });
-RichTextDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef }
-];
-RichTextDirective.propDecorators = {
-    editable: [{ type: Input, args: ['scRichTextEditable',] }],
-    field: [{ type: Input, args: ['scRichText',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(RichTextDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[scRichText]'
-            }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }]; }, { editable: [{
-            type: Input,
-            args: ['scRichTextEditable']
-        }], field: [{
-            type: Input,
-            args: ['scRichText']
-        }] }); })();
-
-class TextDirective {
-    constructor(viewContainer, templateRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.editable = true;
-        this.encode = true;
-    }
-    ngOnChanges(changes) {
-        if (changes.field || changes.editable || changes.encode) {
-            if (!this.viewRef) {
-                this.viewContainer.clear();
-                this.viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-            }
-            this.updateView();
-        }
-    }
-    updateView() {
-        const field = this.field;
-        let editable = this.editable;
-        if (!field || (!field.editable && (field.value === undefined || field.value === ''))) {
-            return;
-        }
-        // can't use editable value if we want to output unencoded
-        if (!this.encode) {
-            editable = false;
-        }
-        const html = field.editable && editable ? field.editable : field.value;
-        const setDangerously = (field.editable && editable) || !this.encode;
-        this.viewRef.rootNodes.forEach((node) => {
-            if (setDangerously) {
-                node.innerHTML = html;
-            }
-            else {
-                node.textContent = html;
-            }
-        });
-    }
-}
-TextDirective.ɵfac = function TextDirective_Factory(t) { return new (t || TextDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef)); };
-TextDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: TextDirective, selectors: [["", "scText", ""]], inputs: { editable: ["scTextEditable", "editable"], encode: ["scTextEncode", "encode"], field: ["scText", "field"] }, features: [ɵngcc0.ɵɵNgOnChangesFeature] });
-TextDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef }
-];
-TextDirective.propDecorators = {
-    editable: [{ type: Input, args: ['scTextEditable',] }],
-    encode: [{ type: Input, args: ['scTextEncode',] }],
-    field: [{ type: Input, args: ['scText',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(TextDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[scText]'
-            }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }]; }, { editable: [{
-            type: Input,
-            args: ['scTextEditable']
-        }], encode: [{
-            type: Input,
-            args: ['scTextEncode']
-        }], field: [{
-            type: Input,
-            args: ['scText']
-        }] }); })();
-
-class LayoutServiceError {
-}
-
-// TODO: these are deprecated and we should switch to using new methods
-const { fetchRouteData, fetchPlaceholderData } = dataApi;
-class LayoutService {
-    static getLayoutServiceError(error) {
-        const layoutServiceError = new LayoutServiceError();
-        const response = error.response;
-        if (response) {
-            layoutServiceError.status = response.status;
-            layoutServiceError.statusText = response.statusText;
-            layoutServiceError.data = response.data;
-        }
-        return throwError(layoutServiceError);
-    }
-    getRouteData(route, options) {
-        return from(fetchRouteData(route, options)).pipe(catchError(LayoutService.getLayoutServiceError));
-    }
-    getPlaceholderData(route, placeholderName, options) {
-        return from(fetchPlaceholderData(placeholderName, route, options)).pipe(catchError(LayoutService.getLayoutServiceError));
-    }
-}
-LayoutService.ɵfac = function LayoutService_Factory(t) { return new (t || LayoutService)(); };
-LayoutService.ɵprov = ɵngcc0.ɵɵdefineInjectable({ token: LayoutService, factory: LayoutService.ɵfac });
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(LayoutService, [{
-        type: Injectable
-    }], null, null); })();
-
-class DateDirective {
-    constructor(viewContainer, templateRef, datePipe) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.datePipe = datePipe;
-        this.editable = true;
-    }
-    ngOnChanges(changes) {
-        if (changes.field || changes.format) {
-            if (!this.viewRef) {
-                this.viewContainer.clear();
-                this.viewRef = this.viewContainer.createEmbeddedView(this.templateRef);
-            }
-            this.updateView();
-        }
-    }
-    updateView() {
-        const field = this.field;
-        if (!field || (!field.editable && !field.value)) {
-            return;
-        }
-        const html = field.editable && this.editable ? field.editable : field.value;
-        const setDangerously = field.editable && this.editable;
-        this.viewRef.rootNodes.forEach((node) => {
-            if (setDangerously) {
-                node.innerHTML = html;
-            }
-            else {
-                node.textContent = this.datePipe.transform(html, this.format, this.timezone, this.locale);
-            }
-        });
-    }
-}
-DateDirective.ɵfac = function DateDirective_Factory(t) { return new (t || DateDirective)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ViewContainerRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.TemplateRef), ɵngcc0.ɵɵdirectiveInject(ɵngcc2.DatePipe)); };
-DateDirective.ɵdir = ɵngcc0.ɵɵdefineDirective({ type: DateDirective, selectors: [["", "scDate", ""]], inputs: { editable: ["scDateEditable", "editable"], format: ["scDateFormat", "format"], timezone: ["scDateTimezone", "timezone"], locale: ["scDateLocale", "locale"], field: ["scDate", "field"] }, features: [ɵngcc0.ɵɵNgOnChangesFeature] });
-DateDirective.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: DatePipe }
-];
-DateDirective.propDecorators = {
-    format: [{ type: Input, args: ['scDateFormat',] }],
-    timezone: [{ type: Input, args: ['scDateTimezone',] }],
-    locale: [{ type: Input, args: ['scDateLocale',] }],
-    editable: [{ type: Input, args: ['scDateEditable',] }],
-    field: [{ type: Input, args: ['scDate',] }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(DateDirective, [{
-        type: Directive,
-        args: [{
-                selector: '[scDate]'
-            }]
-    }], function () { return [{ type: ɵngcc0.ViewContainerRef }, { type: ɵngcc0.TemplateRef }, { type: ɵngcc2.DatePipe }]; }, { editable: [{
-            type: Input,
-            args: ['scDateEditable']
-        }], format: [{
-            type: Input,
-            args: ['scDateFormat']
-        }], timezone: [{
-            type: Input,
-            args: ['scDateTimezone']
-        }], locale: [{
-            type: Input,
-            args: ['scDateLocale']
-        }], field: [{
-            type: Input,
-            args: ['scDate']
-        }] }); })();
-
-class MissingComponentComponent {
-}
-MissingComponentComponent.ɵfac = function MissingComponentComponent_Factory(t) { return new (t || MissingComponentComponent)(); };
-MissingComponentComponent.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: MissingComponentComponent, selectors: [["sc-missing-component"]], inputs: { rendering: "rendering" }, decls: 5, vars: 1, consts: [[2, "background", "darkorange", "outline", "5px solid orange", "padding", "10px", "color", "white", "max-width", "500px"]], template: function MissingComponentComponent_Template(rf, ctx) { if (rf & 1) {
-        ɵngcc0.ɵɵelementStart(0, "div", 0);
-        ɵngcc0.ɵɵelementStart(1, "h2");
-        ɵngcc0.ɵɵtext(2);
-        ɵngcc0.ɵɵelementEnd();
-        ɵngcc0.ɵɵelementStart(3, "p");
-        ɵngcc0.ɵɵtext(4, "JSS component is missing Angular component implementation.");
-        ɵngcc0.ɵɵelementEnd();
-        ɵngcc0.ɵɵelementEnd();
-    } if (rf & 2) {
-        ɵngcc0.ɵɵadvance(2);
-        ɵngcc0.ɵɵtextInterpolate(ctx.rendering.componentName);
-    } }, encapsulation: 2 });
-MissingComponentComponent.propDecorators = {
-    rendering: [{ type: Input }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(MissingComponentComponent, [{
-        type: Component,
-        args: [{
-                selector: 'sc-missing-component',
-                template: `
-    <div
-      style="background: darkorange; outline: 5px solid orange; padding: 10px; color: white; max-width: 500px;"
-    >
-      <h2>{{ rendering.componentName }}</h2>
-      <p>JSS component is missing Angular component implementation.</p>
-    </div>
-  `
-            }]
-    }], null, { rendering: [{
-            type: Input
-        }] }); })();
-
-/**
- * Renders a single JSS component given a rendering definition.
- * Useful inside templated placeholders.
- */
-class RenderComponentComponent {
-    constructor(componentFactoryResolver, differs, componentFactory, missingComponentComponent) {
-        this.componentFactoryResolver = componentFactoryResolver;
-        this.differs = differs;
-        this.componentFactory = componentFactory;
-        this.missingComponentComponent = missingComponentComponent;
-        this.destroyed = false;
-    }
-    set inputs(value) {
-        this._inputs = value;
-        if (!this._differ && value) {
-            this._differ = this.differs.find(value).create();
-        }
-    }
-    ngOnChanges(changes) {
-        if (changes.rendering) {
-            this._render();
-        }
-    }
-    _setComponentInputs(componentInstance, inputs) {
-        Object.entries(inputs).forEach(([input, inputValue]) => (componentInstance[input] = inputValue));
-    }
-    _subscribeComponentOutputs(componentInstance, outputs) {
-        Object.keys(outputs)
-            .filter((output) => componentInstance[output] && componentInstance[output] instanceof Observable)
-            .forEach((output) => componentInstance[output]
-            .pipe(takeWhile(() => !this.destroyed))
-            .subscribe(outputs[output]));
-    }
-    _render() {
-        this.view.clear();
-        if (!this.rendering) {
-            return;
-        }
-        const resolveComponent = isRawRendering(this.rendering)
-            ? Promise.resolve({
-                componentImplementation: RawComponent,
-                componentDefinition: this.rendering,
-            })
-            : this.componentFactory.getComponent(this.rendering);
-        resolveComponent.then((rendering) => {
-            if (!rendering.componentImplementation) {
-                const componentName = rendering.componentDefinition.componentName;
-                console.error(`Attempted to render unknown component ${componentName}.`, `Ensure component is mapped, like:
-          JssModule.withComponents([
-            { name: '${componentName}', type: ${componentName}Component }
-          ])`);
-                rendering.componentImplementation = this.missingComponentComponent;
-            }
-            const componentFactory = rendering.componentFactory ||
-                this.componentFactoryResolver.resolveComponentFactory(rendering.componentImplementation);
-            const componentInstance = this.view.createComponent(componentFactory, 0).instance;
-            componentInstance.rendering = rendering.componentDefinition;
-            if (this._inputs) {
-                this._setComponentInputs(componentInstance, this._inputs);
-            }
-            if (this.outputs) {
-                this._subscribeComponentOutputs(componentInstance, this.outputs);
-            }
-        });
-    }
-}
-RenderComponentComponent.ɵfac = function RenderComponentComponent_Factory(t) { return new (t || RenderComponentComponent)(ɵngcc0.ɵɵdirectiveInject(ɵngcc0.ComponentFactoryResolver), ɵngcc0.ɵɵdirectiveInject(ɵngcc0.KeyValueDiffers), ɵngcc0.ɵɵdirectiveInject(JssComponentFactoryService), ɵngcc0.ɵɵdirectiveInject(PLACEHOLDER_MISSING_COMPONENT_COMPONENT)); };
-RenderComponentComponent.ɵcmp = ɵngcc0.ɵɵdefineComponent({ type: RenderComponentComponent, selectors: [["sc-render-component"]], viewQuery: function RenderComponentComponent_Query(rf, ctx) { if (rf & 1) {
-        ɵngcc0.ɵɵviewQuery(_c0, 3, ViewContainerRef);
-    } if (rf & 2) {
-        let _t;
-        ɵngcc0.ɵɵqueryRefresh(_t = ɵngcc0.ɵɵloadQuery()) && (ctx.view = _t.first);
-    } }, inputs: { inputs: "inputs", rendering: "rendering", outputs: "outputs" }, features: [ɵngcc0.ɵɵNgOnChangesFeature], decls: 2, vars: 0, consts: [["view", ""]], template: function RenderComponentComponent_Template(rf, ctx) { if (rf & 1) {
-        ɵngcc0.ɵɵtemplate(0, RenderComponentComponent_ng_template_0_Template, 0, 0, "ng-template", null, 0, ɵngcc0.ɵɵtemplateRefExtractor);
-    } }, encapsulation: 2 });
-RenderComponentComponent.ctorParameters = () => [
-    { type: ComponentFactoryResolver },
-    { type: KeyValueDiffers },
-    { type: JssComponentFactoryService },
-    { type: Type, decorators: [{ type: Inject, args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT,] }] }
-];
-RenderComponentComponent.propDecorators = {
-    rendering: [{ type: Input }],
-    outputs: [{ type: Input }],
-    view: [{ type: ViewChild, args: ['view', { read: ViewContainerRef, static: true },] }],
-    inputs: [{ type: Input }]
-};
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(RenderComponentComponent, [{
-        type: Component,
-        args: [{
-                selector: 'sc-render-component',
-                template: `
-    <ng-template #view></ng-template>
-  `
-            }]
-    }], function () { return [{ type: ɵngcc0.ComponentFactoryResolver }, { type: ɵngcc0.KeyValueDiffers }, { type: JssComponentFactoryService }, { type: ɵngcc0.Type, decorators: [{
-                type: Inject,
-                args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT]
-            }] }]; }, { inputs: [{
-            type: Input
-        }], rendering: [{
-            type: Input
-        }], outputs: [{
-            type: Input
-        }], view: [{
-            type: ViewChild,
-            args: ['view', { read: ViewContainerRef, static: true }]
-        }] }); })();
-
-class JssModule {
-    /**
-     * Instantiates the JSS module with no component factory.
-     * Useful for using it from libraries. Most of the time you'd want withComponents()
-     * @returns {ModuleWithProviders<JssModule>} module
-     */
-    static forRoot() {
-        return {
-            ngModule: JssModule,
-            providers: [LayoutService, DatePipe, JssComponentFactoryService],
-        };
-    }
-    /**
-     * Instantiates a module for a lazy-loaded JSS component
-     * @param {Type<any>} component
-     * @returns {ModuleWithProviders<JssModule>} module
-     */
-    static forChild(component) {
-        return {
-            ngModule: JssModule,
-            providers: [
-                { provide: ANALYZE_FOR_ENTRY_COMPONENTS, useValue: component, multi: true },
-                { provide: ROUTES, useValue: [], multi: true },
-                { provide: DYNAMIC_COMPONENT, useValue: component },
-            ],
-        };
-    }
-    /**
-     * Instantiates the JSS module and specifies the mapping from component name to component implementation.
-     * Appropriate when defining the set of JSS components that your app is aware of.
-     * @param {ComponentNameAndType[]} components
-     * @param {ComponentNameAndModule[]} [lazyComponents]
-     * @returns {ModuleWithProviders<JssModule>} module
-     */
-    static withComponents(components, lazyComponents) {
-        return {
-            ngModule: JssModule,
-            providers: [
-                {
-                    provide: ANALYZE_FOR_ENTRY_COMPONENTS,
-                    useValue: components,
-                    multi: true,
-                },
-                { provide: PLACEHOLDER_COMPONENTS, useValue: components },
-                { provide: PLACEHOLDER_LAZY_COMPONENTS, useValue: lazyComponents || [] },
-                { provide: ROUTES, useValue: lazyComponents || [], multi: true },
-                { provide: PLACEHOLDER_MISSING_COMPONENT_COMPONENT, useValue: MissingComponentComponent },
-                ...JssModule.forRoot().providers,
-            ],
-        };
-    }
-}
-JssModule.ɵfac = function JssModule_Factory(t) { return new (t || JssModule)(); };
-JssModule.ɵmod = ɵngcc0.ɵɵdefineNgModule({ type: JssModule });
-JssModule.ɵinj = ɵngcc0.ɵɵdefineInjector({ imports: [[CommonModule]] });
-(function () { (typeof ngJitMode === "undefined" || ngJitMode) && ɵngcc0.ɵɵsetNgModuleScope(JssModule, { declarations: function () { return [FileDirective, ImageDirective, LinkDirective, RouterLinkDirective, GenericLinkDirective, DateDirective, RenderEachDirective, RenderEmptyDirective, PlaceholderLoadingDirective, RenderComponentComponent, PlaceholderComponent, RawComponent, RichTextDirective, TextDirective, MissingComponentComponent]; }, imports: function () { return [CommonModule]; }, exports: function () { return [FileDirective, ImageDirective, DateDirective, LinkDirective, RouterLinkDirective, GenericLinkDirective, RenderEachDirective, RenderEmptyDirective, RenderComponentComponent, PlaceholderComponent, PlaceholderLoadingDirective, RichTextDirective, TextDirective]; } }); })();
-(function () { (typeof ngDevMode === "undefined" || ngDevMode) && ɵngcc0.ɵsetClassMetadata(JssModule, [{
-        type: NgModule,
-        args: [{
-                imports: [CommonModule],
-                declarations: [
-                    FileDirective,
-                    ImageDirective,
-                    LinkDirective,
-                    RouterLinkDirective,
-                    GenericLinkDirective,
-                    DateDirective,
-                    RenderEachDirective,
-                    RenderEmptyDirective,
-                    PlaceholderLoadingDirective,
-                    RenderComponentComponent,
-                    PlaceholderComponent,
-                    RawComponent,
-                    RichTextDirective,
-                    TextDirective,
-                    MissingComponentComponent,
-                ],
-                exports: [
-                    FileDirective,
-                    ImageDirective,
-                    DateDirective,
-                    LinkDirective,
-                    RouterLinkDirective,
-                    GenericLinkDirective,
-                    RenderEachDirective,
-                    RenderEmptyDirective,
-                    RenderComponentComponent,
-                    PlaceholderComponent,
-                    PlaceholderLoadingDirective,
-                    RichTextDirective,
-                    TextDirective,
-                ],
-                entryComponents: [RawComponent, MissingComponentComponent]
-            }]
-    }], null, null); })();
-
-/**
- * @description in Experience Editor with an Angular sample app, anchor tags
- * with both onclick and href attributes will use the href, blocking the onclick from firing.
- * This function makes it so the anchor tags function as intended in an Angular sample when using Experience Editor
- *
- * The Mutation Observer API is used to observe changes to the body, then select all elements with href="#" and an onclick,
- * and replaces the # value with javascript:void(0); which prevents the anchor tag from blocking the onclick event handler.
- * @see Mutation Observer API: https://developer.mozilla.org/en-US/docs/Web/API/MutationObserver/MutationObserver
- */
-const handleEditorAnchors = () => {
-    // Angular gives the href attribute priority over the onclick attribute if both are present, so we must replace
-    // the href attribute to avoid overriding the onclick in Experience Editor
-    if (!window || !isExperienceEditorActive()) {
-        return;
-    }
-    const targetNode = document.querySelector('body');
-    const callback = (mutationList) => {
-        mutationList.forEach((mutation) => {
-            const btns = document.querySelectorAll('.scChromeDropDown > a[href="#"], a[onclick]');
-            if (mutation.type === 'childList') {
-                btns.forEach((link) => {
-                    link.href = 'javascript:void(0);';
-                });
-            }
-            return;
-        });
-    };
-    const observer = new MutationObserver(callback);
-    const observerOptions = {
-        childList: true,
-        subtree: true,
-    };
-    if (targetNode) {
-        observer.observe(targetNode, observerOptions);
-    }
-};
-
-/**
- * Generated bundle index. Do not edit.
- */
-
-export { ComponentNameAndType, DYNAMIC_COMPONENT, FileDirective, GenericLinkDirective, ImageDirective, JssModule, LayoutService, LayoutServiceError, LinkDirective, PlaceholderComponent, PlaceholderLoadingDirective, RichTextDirective, RouterLinkDirective, TextDirective, handleEditorAnchors, isRawRendering, PLACEHOLDER_COMPONENTS as ɵb, PLACEHOLDER_LAZY_COMPONENTS as ɵc, PLACEHOLDER_MISSING_COMPONENT_COMPONENT as ɵd, RenderEachDirective as ɵe, RenderEmptyDirective as ɵf, JssComponentFactoryService as ɵg, DateDirective as ɵh, RenderComponentComponent as ɵi, RawComponent as ɵj, MissingComponentComponent as ɵk };
-
-//# sourceMappingURL=sitecore-jss-sitecore-jss-angular.js.map