@sitecore-jss/sitecore-jss-angular 13.2.4 → 13.2.5-canary.2

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

@@ -7,1146 +7,1146 @@ 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."
- */
-let FileDirective = 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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef }
-];
-__decorate([
-    Input('scFile')
-], FileDirective.prototype, "field", void 0);
-FileDirective = __decorate([
-    Directive({ selector: '[scFile]' })
+/**
+ * File fields cannot be managed via the EE. We never output "editable."
+ */
+let FileDirective = 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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef }
+];
+__decorate([
+    Input('scFile')
+], FileDirective.prototype, "field", void 0);
+FileDirective = __decorate([
+    Directive({ selector: '[scFile]' })
 ], FileDirective);
 
-let ImageDirective = class ImageDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-        this.inlineRef = null;
-        // tslint:disable-next-line:no-input-rename
-        this.editable = true;
-        // tslint:disable-next-line:no-input-rename
-        this.urlParams = {};
-        // tslint:disable-next-line:no-input-rename
-        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({}, 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({}, fieldAttrs, parsedAttrs);
-        // tslint: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);
-        if (srcSet) {
-            // replace with HTML-formatted srcset, including updated image URLs
-            newAttrs.srcSet = mediaApi.getSrcSet(src, srcSet, imageParams);
-        }
-        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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-__decorate([
-    Input('scImage')
-], ImageDirective.prototype, "field", void 0);
-__decorate([
-    Input('scImageEditable')
-], ImageDirective.prototype, "editable", void 0);
-__decorate([
-    Input('scImageUrlParams')
-], ImageDirective.prototype, "urlParams", void 0);
-__decorate([
-    Input('scImageAttrs')
-], ImageDirective.prototype, "attrs", void 0);
-ImageDirective = __decorate([
-    Directive({ selector: '[scImage]' })
+let ImageDirective = class ImageDirective {
+    constructor(viewContainer, templateRef, renderer, elementRef) {
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.inlineRef = null;
+        // tslint:disable-next-line:no-input-rename
+        this.editable = true;
+        // tslint:disable-next-line:no-input-rename
+        this.urlParams = {};
+        // tslint:disable-next-line:no-input-rename
+        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({}, 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({}, fieldAttrs, parsedAttrs);
+        // tslint: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);
+        if (srcSet) {
+            // replace with HTML-formatted srcset, including updated image URLs
+            newAttrs.srcSet = mediaApi.getSrcSet(src, srcSet, imageParams);
+        }
+        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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef },
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+__decorate([
+    Input('scImage')
+], ImageDirective.prototype, "field", void 0);
+__decorate([
+    Input('scImageEditable')
+], ImageDirective.prototype, "editable", void 0);
+__decorate([
+    Input('scImageUrlParams')
+], ImageDirective.prototype, "urlParams", void 0);
+__decorate([
+    Input('scImageAttrs')
+], ImageDirective.prototype, "attrs", void 0);
+ImageDirective = __decorate([
+    Directive({ selector: '[scImage]' })
 ], ImageDirective);
 
-let LinkDirective = class LinkDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.renderer = renderer;
-        this.elementRef = elementRef;
-        this.inlineRef = null;
-        // tslint:disable-next-line:no-input-rename
-        this.editable = true;
-        // tslint:disable-next-line:no-input-rename
-        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({}, 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]) => 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({}, 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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-__decorate([
-    Input('scLinkEditable')
-], LinkDirective.prototype, "editable", void 0);
-__decorate([
-    Input('scLinkAttrs')
-], LinkDirective.prototype, "attrs", void 0);
-__decorate([
-    Input('scLink')
-], LinkDirective.prototype, "field", void 0);
-LinkDirective = __decorate([
-    Directive({ selector: '[scLink]' })
+let LinkDirective = class LinkDirective {
+    constructor(viewContainer, templateRef, renderer, elementRef) {
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+        this.renderer = renderer;
+        this.elementRef = elementRef;
+        this.inlineRef = null;
+        // tslint:disable-next-line:no-input-rename
+        this.editable = true;
+        // tslint:disable-next-line:no-input-rename
+        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({}, 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]) => 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({}, 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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef },
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+__decorate([
+    Input('scLinkEditable')
+], LinkDirective.prototype, "editable", void 0);
+__decorate([
+    Input('scLinkAttrs')
+], LinkDirective.prototype, "attrs", void 0);
+__decorate([
+    Input('scLink')
+], LinkDirective.prototype, "field", void 0);
+LinkDirective = __decorate([
+    Directive({ selector: '[scLink]' })
 ], LinkDirective);
 
-let RouterLinkDirective = class RouterLinkDirective extends LinkDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef, router) {
-        super(viewContainer, templateRef, renderer, elementRef);
-        this.router = router;
-        // tslint:disable-next-line:no-input-rename
-        this.editable = true;
-        // tslint:disable-next-line:no-input-rename
-        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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef },
-    { type: Router }
-];
-__decorate([
-    Input('scRouterLinkEditable')
-], RouterLinkDirective.prototype, "editable", void 0);
-__decorate([
-    Input('scRouterLinkAttrs')
-], RouterLinkDirective.prototype, "attrs", void 0);
-__decorate([
-    Input('scRouterLink')
-], RouterLinkDirective.prototype, "field", void 0);
-RouterLinkDirective = __decorate([
-    Directive({ selector: '[scRouterLink]' })
+let RouterLinkDirective = class RouterLinkDirective extends LinkDirective {
+    constructor(viewContainer, templateRef, renderer, elementRef, router) {
+        super(viewContainer, templateRef, renderer, elementRef);
+        this.router = router;
+        // tslint:disable-next-line:no-input-rename
+        this.editable = true;
+        // tslint:disable-next-line:no-input-rename
+        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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef },
+    { type: Renderer2 },
+    { type: ElementRef },
+    { type: Router }
+];
+__decorate([
+    Input('scRouterLinkEditable')
+], RouterLinkDirective.prototype, "editable", void 0);
+__decorate([
+    Input('scRouterLinkAttrs')
+], RouterLinkDirective.prototype, "attrs", void 0);
+__decorate([
+    Input('scRouterLink')
+], RouterLinkDirective.prototype, "field", void 0);
+RouterLinkDirective = __decorate([
+    Directive({ selector: '[scRouterLink]' })
 ], RouterLinkDirective);
 
-let GenericLinkDirective = class GenericLinkDirective extends LinkDirective {
-    constructor(viewContainer, templateRef, renderer, elementRef, router) {
-        super(viewContainer, templateRef, renderer, elementRef);
-        this.router = router;
-        // tslint:disable-next-line:no-input-rename
-        this.editable = true;
-        // tslint:disable-next-line:no-input-rename
-        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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: Renderer2 },
-    { type: ElementRef },
-    { type: Router }
-];
-__decorate([
-    Input('scGenericLinkEditable')
-], GenericLinkDirective.prototype, "editable", void 0);
-__decorate([
-    Input('scGenericLinkAttrs')
-], GenericLinkDirective.prototype, "attrs", void 0);
-__decorate([
-    Input('scGenericLink')
-], GenericLinkDirective.prototype, "field", void 0);
-__decorate([
-    Input('scGenericLinkExtras')
-], GenericLinkDirective.prototype, "extras", void 0);
-GenericLinkDirective = __decorate([
-    Directive({ selector: '[scGenericLink]' })
+let GenericLinkDirective = class GenericLinkDirective extends LinkDirective {
+    constructor(viewContainer, templateRef, renderer, elementRef, router) {
+        super(viewContainer, templateRef, renderer, elementRef);
+        this.router = router;
+        // tslint:disable-next-line:no-input-rename
+        this.editable = true;
+        // tslint:disable-next-line:no-input-rename
+        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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef },
+    { type: Renderer2 },
+    { type: ElementRef },
+    { type: Router }
+];
+__decorate([
+    Input('scGenericLinkEditable')
+], GenericLinkDirective.prototype, "editable", void 0);
+__decorate([
+    Input('scGenericLinkAttrs')
+], GenericLinkDirective.prototype, "attrs", void 0);
+__decorate([
+    Input('scGenericLink')
+], GenericLinkDirective.prototype, "field", void 0);
+__decorate([
+    Input('scGenericLinkExtras')
+], GenericLinkDirective.prototype, "extras", void 0);
+GenericLinkDirective = __decorate([
+    Directive({ selector: '[scGenericLink]' })
 ], GenericLinkDirective);
 
-/** Registers a statically loaded component */
-class ComponentNameAndType {
-}
-function instanceOfComponentNameAndType(object) {
-    return 'type' in 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');
+/** Registers a statically loaded component */
+class ComponentNameAndType {
+}
+function instanceOfComponentNameAndType(object) {
+    return 'type' in 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');
 
-let RawComponent = 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) {
-            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.ctorParameters = () => [
-    { type: Renderer2 },
-    { type: ElementRef }
-];
-__decorate([
-    Input()
-], RawComponent.prototype, "rendering", void 0);
-RawComponent = __decorate([
-    Component({
-        selector: 'sc-raw',
-        template: ``
-    })
+let RawComponent = 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) {
+            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.ctorParameters = () => [
+    { type: Renderer2 },
+    { type: ElementRef }
+];
+__decorate([
+    Input()
+], RawComponent.prototype, "rendering", void 0);
+RawComponent = __decorate([
+    Component({
+        selector: 'sc-raw',
+        template: ``
+    })
 ], RawComponent);
 
-function isRawRendering(rendering) {
-    return !rendering.componentName && rendering.name !== undefined;
+function isRawRendering(rendering) {
+    return !rendering.componentName && rendering.name !== undefined;
 }
 
-let JssComponentFactoryService = class JssComponentFactoryService {
-    constructor(injector, components, lazyComponents) {
-        this.injector = injector;
-        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));
-        }
-    }
-    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 lazyComponent.loadChildren()
-                .then((ngModuleFactory) => {
-                let componentType = null;
-                const moduleRef = ngModuleFactory.create(this.injector);
-                const dynamicComponentType = moduleRef.injector.get(DYNAMIC_COMPONENT);
-                if (!dynamicComponentType) {
-                    throw new Error(
-                    // tslint:disable-next-line:max-line-length
-                    `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(
-                        // tslint:disable-next-line:max-line-length
-                        `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.ctorParameters = () => [
-    { type: Injector },
-    { type: Array, decorators: [{ type: Inject, args: [PLACEHOLDER_COMPONENTS,] }] },
-    { type: Array, decorators: [{ type: Inject, args: [PLACEHOLDER_LAZY_COMPONENTS,] }] }
-];
-JssComponentFactoryService = __decorate([
-    Injectable(),
-    __param(1, Inject(PLACEHOLDER_COMPONENTS)),
-    __param(2, Inject(PLACEHOLDER_LAZY_COMPONENTS))
+let JssComponentFactoryService = class JssComponentFactoryService {
+    constructor(injector, components, lazyComponents) {
+        this.injector = injector;
+        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));
+        }
+    }
+    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 lazyComponent.loadChildren()
+                .then((ngModuleFactory) => {
+                let componentType = null;
+                const moduleRef = ngModuleFactory.create(this.injector);
+                const dynamicComponentType = moduleRef.injector.get(DYNAMIC_COMPONENT);
+                if (!dynamicComponentType) {
+                    throw new Error(
+                    // tslint:disable-next-line:max-line-length
+                    `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(
+                        // tslint:disable-next-line:max-line-length
+                        `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.ctorParameters = () => [
+    { type: Injector },
+    { type: Array, decorators: [{ type: Inject, args: [PLACEHOLDER_COMPONENTS,] }] },
+    { type: Array, decorators: [{ type: Inject, args: [PLACEHOLDER_LAZY_COMPONENTS,] }] }
+];
+JssComponentFactoryService = __decorate([
+    Injectable(),
+    __param(1, Inject(PLACEHOLDER_COMPONENTS)),
+    __param(2, Inject(PLACEHOLDER_LAZY_COMPONENTS))
 ], JssComponentFactoryService);
 
-let PlaceholderLoadingDirective = class PlaceholderLoadingDirective {
-    constructor(templateRef) {
-        this.templateRef = templateRef;
-    }
-};
-PlaceholderLoadingDirective.ctorParameters = () => [
-    { type: TemplateRef }
-];
-PlaceholderLoadingDirective = __decorate([
-    Directive({
-        selector: '[scPlaceholderLoading]',
-    })
+let PlaceholderLoadingDirective = class PlaceholderLoadingDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+};
+PlaceholderLoadingDirective.ctorParameters = () => [
+    { type: TemplateRef }
+];
+PlaceholderLoadingDirective = __decorate([
+    Directive({
+        selector: '[scPlaceholderLoading]',
+    })
 ], PlaceholderLoadingDirective);
 
-let RenderEachDirective = class RenderEachDirective {
-    constructor(templateRef) {
-        this.templateRef = templateRef;
-    }
-};
-RenderEachDirective.ctorParameters = () => [
-    { type: TemplateRef }
-];
-RenderEachDirective = __decorate([
-    Directive({
-        // tslint:disable-next-line:directive-selector
-        selector: '[renderEach]',
-    })
+let RenderEachDirective = class RenderEachDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+};
+RenderEachDirective.ctorParameters = () => [
+    { type: TemplateRef }
+];
+RenderEachDirective = __decorate([
+    Directive({
+        // tslint:disable-next-line:directive-selector
+        selector: '[renderEach]',
+    })
 ], RenderEachDirective);
 
-let RenderEmptyDirective = class RenderEmptyDirective {
-    constructor(templateRef) {
-        this.templateRef = templateRef;
-    }
-};
-RenderEmptyDirective.ctorParameters = () => [
-    { type: TemplateRef }
-];
-RenderEmptyDirective = __decorate([
-    Directive({
-        // tslint:disable-next-line:directive-selector
-        selector: '[renderEmpty]',
-    })
+let RenderEmptyDirective = class RenderEmptyDirective {
+    constructor(templateRef) {
+        this.templateRef = templateRef;
+    }
+};
+RenderEmptyDirective.ctorParameters = () => [
+    { type: TemplateRef }
+];
+RenderEmptyDirective = __decorate([
+    Directive({
+        // tslint:disable-next-line:directive-selector
+        selector: '[renderEmpty]',
+    })
 ], RenderEmptyDirective);
 
-function getPlaceholder(rendering, name) {
-    if (rendering && rendering.placeholders && Object.keys(rendering.placeholders).length > 0) {
-        return rendering.placeholders[name];
-    }
-    return null;
-}
-let PlaceholderComponent = 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) {
-            // tslint:disable-next-line:max-line-length
-            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;
+function getPlaceholder(rendering, name) {
+    if (rendering && rendering.placeholders && Object.keys(rendering.placeholders).length > 0) {
+        return rendering.placeholders[name];
+    }
+    return null;
+}
+let PlaceholderComponent = 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) {
+            // tslint:disable-next-line:max-line-length
+            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.ctorParameters = () => [
-    { type: ComponentFactoryResolver },
-    { type: KeyValueDiffers },
-    { type: JssComponentFactoryService },
-    { type: ChangeDetectorRef },
-    { type: ElementRef },
-    { type: Renderer2 },
-    { type: Type, decorators: [{ type: Inject, args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT,] }] }
-];
-__decorate([
-    Input()
-], PlaceholderComponent.prototype, "name", void 0);
-__decorate([
-    Input()
-], PlaceholderComponent.prototype, "rendering", void 0);
-__decorate([
-    Input()
-], PlaceholderComponent.prototype, "renderings", void 0);
-__decorate([
-    Input()
-], PlaceholderComponent.prototype, "outputs", void 0);
-__decorate([
-    Output()
-], PlaceholderComponent.prototype, "loaded", void 0);
-__decorate([
-    ViewChild('view', { read: ViewContainerRef, static: true })
-], PlaceholderComponent.prototype, "view", void 0);
-__decorate([
-    ContentChild(RenderEachDirective, { static: true })
-], PlaceholderComponent.prototype, "renderEachTemplate", void 0);
-__decorate([
-    ContentChild(RenderEmptyDirective, { static: true })
-], PlaceholderComponent.prototype, "renderEmptyTemplate", void 0);
-__decorate([
-    ContentChild(PlaceholderLoadingDirective, { static: true })
-], PlaceholderComponent.prototype, "placeholderLoading", void 0);
-__decorate([
-    Input()
-], PlaceholderComponent.prototype, "inputs", null);
-PlaceholderComponent = __decorate([
-    Component({
-        selector: 'sc-placeholder,[sc-placeholder]',
+        ])`);
+            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.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: KeyValueDiffers },
+    { type: JssComponentFactoryService },
+    { type: ChangeDetectorRef },
+    { type: ElementRef },
+    { type: Renderer2 },
+    { type: Type, decorators: [{ type: Inject, args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT,] }] }
+];
+__decorate([
+    Input()
+], PlaceholderComponent.prototype, "name", void 0);
+__decorate([
+    Input()
+], PlaceholderComponent.prototype, "rendering", void 0);
+__decorate([
+    Input()
+], PlaceholderComponent.prototype, "renderings", void 0);
+__decorate([
+    Input()
+], PlaceholderComponent.prototype, "outputs", void 0);
+__decorate([
+    Output()
+], PlaceholderComponent.prototype, "loaded", void 0);
+__decorate([
+    ViewChild('view', { read: ViewContainerRef, static: true })
+], PlaceholderComponent.prototype, "view", void 0);
+__decorate([
+    ContentChild(RenderEachDirective, { static: true })
+], PlaceholderComponent.prototype, "renderEachTemplate", void 0);
+__decorate([
+    ContentChild(RenderEmptyDirective, { static: true })
+], PlaceholderComponent.prototype, "renderEmptyTemplate", void 0);
+__decorate([
+    ContentChild(PlaceholderLoadingDirective, { static: true })
+], PlaceholderComponent.prototype, "placeholderLoading", void 0);
+__decorate([
+    Input()
+], PlaceholderComponent.prototype, "inputs", null);
+PlaceholderComponent = __decorate([
+    Component({
+        selector: 'sc-placeholder,[sc-placeholder]',
         template: `
     <ng-template *ngIf="isLoading" [ngTemplateOutlet]="placeholderLoading?.templateRef"></ng-template>
     <ng-template #view></ng-template>
-  `
-    }),
-    __param(6, Inject(PLACEHOLDER_MISSING_COMPONENT_COMPONENT))
+  `
+    }),
+    __param(6, Inject(PLACEHOLDER_MISSING_COMPONENT_COMPONENT))
 ], PlaceholderComponent);
 
-let RichTextDirective = class RichTextDirective {
-    constructor(viewContainer, templateRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        // tslint:disable-next-line:no-input-rename
-        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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef }
-];
-__decorate([
-    Input('scRichTextEditable')
-], RichTextDirective.prototype, "editable", void 0);
-__decorate([
-    Input('scRichText')
-], RichTextDirective.prototype, "field", void 0);
-RichTextDirective = __decorate([
-    Directive({
-        selector: '[scRichText]',
-    })
+let RichTextDirective = class RichTextDirective {
+    constructor(viewContainer, templateRef) {
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+        // tslint:disable-next-line:no-input-rename
+        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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef }
+];
+__decorate([
+    Input('scRichTextEditable')
+], RichTextDirective.prototype, "editable", void 0);
+__decorate([
+    Input('scRichText')
+], RichTextDirective.prototype, "field", void 0);
+RichTextDirective = __decorate([
+    Directive({
+        selector: '[scRichText]',
+    })
 ], RichTextDirective);
 
-let TextDirective = class TextDirective {
-    constructor(viewContainer, templateRef) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        // tslint:disable-next-line:no-input-rename
-        this.editable = true;
-        // tslint:disable-next-line:no-input-rename
-        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)) {
-            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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef }
-];
-__decorate([
-    Input('scTextEditable')
-], TextDirective.prototype, "editable", void 0);
-__decorate([
-    Input('scTextEncode')
-], TextDirective.prototype, "encode", void 0);
-__decorate([
-    Input('scText')
-], TextDirective.prototype, "field", void 0);
-TextDirective = __decorate([
-    Directive({
-        selector: '[scText]',
-    })
+let TextDirective = class TextDirective {
+    constructor(viewContainer, templateRef) {
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+        // tslint:disable-next-line:no-input-rename
+        this.editable = true;
+        // tslint:disable-next-line:no-input-rename
+        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)) {
+            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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef }
+];
+__decorate([
+    Input('scTextEditable')
+], TextDirective.prototype, "editable", void 0);
+__decorate([
+    Input('scTextEncode')
+], TextDirective.prototype, "encode", void 0);
+__decorate([
+    Input('scText')
+], TextDirective.prototype, "field", void 0);
+TextDirective = __decorate([
+    Directive({
+        selector: '[scText]',
+    })
 ], TextDirective);
 
-class LayoutServiceError {
+class LayoutServiceError {
 }
 
-var LayoutService_1;
-const { fetchRouteData, fetchPlaceholderData } = dataApi;
-let LayoutService = LayoutService_1 = 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_1.getLayoutServiceError));
-    }
-    getPlaceholderData(route, placeholderName, options) {
-        return from(fetchPlaceholderData(placeholderName, route, options))
-            .pipe(catchError(LayoutService_1.getLayoutServiceError));
-    }
-};
-LayoutService = LayoutService_1 = __decorate([
-    Injectable()
+var LayoutService_1;
+const { fetchRouteData, fetchPlaceholderData } = dataApi;
+let LayoutService = LayoutService_1 = 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_1.getLayoutServiceError));
+    }
+    getPlaceholderData(route, placeholderName, options) {
+        return from(fetchPlaceholderData(placeholderName, route, options))
+            .pipe(catchError(LayoutService_1.getLayoutServiceError));
+    }
+};
+LayoutService = LayoutService_1 = __decorate([
+    Injectable()
 ], LayoutService);
 
-let DateDirective = class DateDirective {
-    constructor(viewContainer, templateRef, datePipe) {
-        this.viewContainer = viewContainer;
-        this.templateRef = templateRef;
-        this.datePipe = datePipe;
-        // tslint:disable-next-line:no-input-rename
-        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.ctorParameters = () => [
-    { type: ViewContainerRef },
-    { type: TemplateRef },
-    { type: DatePipe }
-];
-__decorate([
-    Input('scDateFormat')
-], DateDirective.prototype, "format", void 0);
-__decorate([
-    Input('scDateTimezone')
-], DateDirective.prototype, "timezone", void 0);
-__decorate([
-    Input('scDateLocale')
-], DateDirective.prototype, "locale", void 0);
-__decorate([
-    Input('scDateEditable')
-], DateDirective.prototype, "editable", void 0);
-__decorate([
-    Input('scDate')
-], DateDirective.prototype, "field", void 0);
-DateDirective = __decorate([
-    Directive({
-        selector: '[scDate]',
-    })
+let DateDirective = class DateDirective {
+    constructor(viewContainer, templateRef, datePipe) {
+        this.viewContainer = viewContainer;
+        this.templateRef = templateRef;
+        this.datePipe = datePipe;
+        // tslint:disable-next-line:no-input-rename
+        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.ctorParameters = () => [
+    { type: ViewContainerRef },
+    { type: TemplateRef },
+    { type: DatePipe }
+];
+__decorate([
+    Input('scDateFormat')
+], DateDirective.prototype, "format", void 0);
+__decorate([
+    Input('scDateTimezone')
+], DateDirective.prototype, "timezone", void 0);
+__decorate([
+    Input('scDateLocale')
+], DateDirective.prototype, "locale", void 0);
+__decorate([
+    Input('scDateEditable')
+], DateDirective.prototype, "editable", void 0);
+__decorate([
+    Input('scDate')
+], DateDirective.prototype, "field", void 0);
+DateDirective = __decorate([
+    Directive({
+        selector: '[scDate]',
+    })
 ], DateDirective);
 
-let MissingComponentComponent = class MissingComponentComponent {
-};
-__decorate([
-    Input()
-], MissingComponentComponent.prototype, "rendering", void 0);
-MissingComponentComponent = __decorate([
-    Component({
-        selector: 'sc-missing-component',
+let MissingComponentComponent = class MissingComponentComponent {
+};
+__decorate([
+    Input()
+], MissingComponentComponent.prototype, "rendering", void 0);
+MissingComponentComponent = __decorate([
+    Component({
+        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>`
-    })
+</div>`
+    })
 ], MissingComponentComponent);
 
-/**
- * Renders a single JSS component given a rendering definition.
- * Useful inside templated placeholders.
- */
-let RenderComponentComponent = 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;
+/**
+ * Renders a single JSS component given a rendering definition.
+ * Useful inside templated placeholders.
+ */
+let RenderComponentComponent = 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.ctorParameters = () => [
-    { type: ComponentFactoryResolver },
-    { type: KeyValueDiffers },
-    { type: JssComponentFactoryService },
-    { type: Type, decorators: [{ type: Inject, args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT,] }] }
-];
-__decorate([
-    Input()
-], RenderComponentComponent.prototype, "rendering", void 0);
-__decorate([
-    Input()
-], RenderComponentComponent.prototype, "outputs", void 0);
-__decorate([
-    ViewChild('view', { read: ViewContainerRef, static: true })
-], RenderComponentComponent.prototype, "view", void 0);
-__decorate([
-    Input()
-], RenderComponentComponent.prototype, "inputs", null);
-RenderComponentComponent = __decorate([
-    Component({
-        selector: 'sc-render-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.ctorParameters = () => [
+    { type: ComponentFactoryResolver },
+    { type: KeyValueDiffers },
+    { type: JssComponentFactoryService },
+    { type: Type, decorators: [{ type: Inject, args: [PLACEHOLDER_MISSING_COMPONENT_COMPONENT,] }] }
+];
+__decorate([
+    Input()
+], RenderComponentComponent.prototype, "rendering", void 0);
+__decorate([
+    Input()
+], RenderComponentComponent.prototype, "outputs", void 0);
+__decorate([
+    ViewChild('view', { read: ViewContainerRef, static: true })
+], RenderComponentComponent.prototype, "view", void 0);
+__decorate([
+    Input()
+], RenderComponentComponent.prototype, "inputs", null);
+RenderComponentComponent = __decorate([
+    Component({
+        selector: 'sc-render-component',
         template: `
     <ng-template #view></ng-template>
-  `
-    }),
-    __param(3, Inject(PLACEHOLDER_MISSING_COMPONENT_COMPONENT))
+  `
+    }),
+    __param(3, Inject(PLACEHOLDER_MISSING_COMPONENT_COMPONENT))
 ], RenderComponentComponent);
 
-var JssModule_1;
-let JssModule = JssModule_1 = class JssModule {
-    /**
-     * Instantiates the JSS module with no component factory.
-     * Useful for using it from libraries. Most of the time you'd want withComponents()
-     */
-    static forRoot() {
-        return {
-            ngModule: JssModule_1,
-            providers: [
-                LayoutService,
-                DatePipe,
-                JssComponentFactoryService,
-            ],
-        };
-    }
-    /** Instantiates a module for a lazy-loaded JSS component */
-    static forChild(component) {
-        return {
-            ngModule: JssModule_1,
-            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.
-     */
-    static withComponents(components, lazyComponents) {
-        return {
-            ngModule: JssModule_1,
-            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_1.forRoot().providers,
-            ],
-        };
-    }
-};
-JssModule = JssModule_1 = __decorate([
-    NgModule({
-        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,
-        ],
-    })
+var JssModule_1;
+let JssModule = JssModule_1 = class JssModule {
+    /**
+     * Instantiates the JSS module with no component factory.
+     * Useful for using it from libraries. Most of the time you'd want withComponents()
+     */
+    static forRoot() {
+        return {
+            ngModule: JssModule_1,
+            providers: [
+                LayoutService,
+                DatePipe,
+                JssComponentFactoryService,
+            ],
+        };
+    }
+    /** Instantiates a module for a lazy-loaded JSS component */
+    static forChild(component) {
+        return {
+            ngModule: JssModule_1,
+            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.
+     */
+    static withComponents(components, lazyComponents) {
+        return {
+            ngModule: JssModule_1,
+            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_1.forRoot().providers,
+            ],
+        };
+    }
+};
+JssModule = JssModule_1 = __decorate([
+    NgModule({
+        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,
+        ],
+    })
 ], JssModule);
 
-/**
- * Generated bundle index. Do not edit.
+/**
+ * Generated bundle index. Do not edit.
  */
 
 export { ComponentNameAndType, DYNAMIC_COMPONENT, FileDirective, GenericLinkDirective, ImageDirective, JssModule, LayoutService, LayoutServiceError, LinkDirective, PlaceholderComponent, PlaceholderLoadingDirective, RichTextDirective, RouterLinkDirective, TextDirective, 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 };