@foblex/m-render 2.5.1

package/esm2022/lib/f-page/f-markdown/domain/markdown/parse-markdown/parse-example-group.mjs

@@ -0,0 +1,92 @@
+import container from 'markdown-it-container';
+import { EMarkdownContainerType } from './e-markdown-container-type';
+import { getContent } from '../utils';
+export class ParseExampleGroup {
+    render() {
+        return [container, EMarkdownContainerType.EXAMPLE_GROUP, {
+                render: (tokens, index) => {
+                    if (this.isOpeningToken(tokens, index)) {
+                        return this.openingExampleGroupHTML(this.generateData(tokens, index));
+                    }
+                    return this.closingExampleGroupHTML();
+                }
+            }];
+    }
+    isNgComponent(token) {
+        return token.info.trim().startsWith(EMarkdownContainerType.EXAMPLE_GROUP);
+    }
+    isOpeningToken(tokens, index) {
+        return tokens[index].nesting === 1;
+    }
+    generateData(tokens, index) {
+        let tabs = '';
+        let views = '';
+        const component = this.parseComponentTags(tokens[index]);
+        if (component) {
+            tabs += this.generateTabButton('Example');
+            views += this.generateExampleView(component);
+        }
+        const content = getContent(tokens, index, EMarkdownContainerType.EXAMPLE_GROUP);
+        if (content) {
+            this.parseData(content).forEach((x) => {
+                tabs += this.generateTabButton(x.fileName);
+                views += this.generateAsyncCodeView(x.url);
+            });
+        }
+        else {
+            tabs = '';
+        }
+        return { tabs, views };
+    }
+    parseComponentTags(token) {
+        if (!this.isNgComponent(token)) {
+            return { tag: '', height: '' };
+        }
+        let cleanedInput = token.info.replace(/ng-component\s*/, '');
+        const tagMatch = cleanedInput.match(/<([a-zA-Z0-9-]+)>.*<\/\1>/);
+        const heightMatch = cleanedInput.match(/\[height\]="(\d+)"/);
+        if (!tagMatch) {
+            throw new Error("Invalid input: no valid tag found");
+        }
+        const tag = tagMatch[0];
+        const height = heightMatch ? heightMatch[1] : undefined;
+        return { tag, height };
+    }
+    parseData(data) {
+        return data.split('\n').map(this.extractFileData).filter(Boolean);
+    }
+    extractFileData(line) {
+        const match = line.match(/\[(.+?)\] <<< (.+)/);
+        return match ? { fileName: match[1], url: match[2] } : null;
+    }
+    openingExampleGroupHTML(data) {
+        return `<div class="f-code-group">${this.groupTabsHTML(data.tabs)}${this.groupBodyHTML(data.views)}`;
+    }
+    groupTabsHTML(content) {
+        let result = `<div class="f-code-group-tabs">${content}</div>`;
+        if (!content) {
+            result = '';
+        }
+        return result;
+    }
+    generateTabButton(content) {
+        return `<button class="f-tab-button">${content}</button>`;
+    }
+    groupBodyHTML(content) {
+        return `<div class="f-code-group-body">${content}`;
+    }
+    generateExampleView(content) {
+        let height = '';
+        if (content.height) {
+            height = `style="height: ${content.height}px"`;
+        }
+        return `<div class="f-example-view" ${height}>${content.tag}</div>`;
+    }
+    generateAsyncCodeView(content) {
+        return `<div class="f-async-code-view">${content}</div>`;
+    }
+    closingExampleGroupHTML() {
+        return `</div></div>\n`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"parse-example-group.js","sourceRoot":"","sources":["../../../../../../../../../projects/m-render/src/lib/f-page/f-markdown/domain/markdown/parse-markdown/parse-example-group.ts"],"names":[],"mappings":"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","sourcesContent":["import container from 'markdown-it-container';\nimport { EMarkdownContainerType } from './e-markdown-container-type';\nimport { IMarkdownItToken } from './i-markdown-it-token';\nimport { getContent } from '../utils';\n\ntype ContainerArgs = [ typeof container, string, { render: any } ]\n\nexport class ParseExampleGroup {\n\n  public render(): ContainerArgs {\n    return [ container, EMarkdownContainerType.EXAMPLE_GROUP, {\n      render: (tokens: IMarkdownItToken[], index: number) => {\n        if (this.isOpeningToken(tokens, index)) {\n          return this.openingExampleGroupHTML(this.generateData(tokens, index));\n        }\n        return this.closingExampleGroupHTML();\n      }\n    } ];\n  }\n\n  private isNgComponent(token: IMarkdownItToken): boolean {\n    return token.info.trim().startsWith(EMarkdownContainerType.EXAMPLE_GROUP);\n  }\n\n  private isOpeningToken(tokens: IMarkdownItToken[], index: number): boolean {\n    return tokens[ index ].nesting === 1;\n  }\n\n  private generateData(tokens: IMarkdownItToken[], index: number): { tabs: string, views: string } {\n    let tabs = '';\n    let views = '';\n    const component = this.parseComponentTags(tokens[ index ]);\n    if (component) {\n      tabs += this.generateTabButton('Example');\n      views += this.generateExampleView(component);\n    }\n    const content = getContent(tokens, index, EMarkdownContainerType.EXAMPLE_GROUP);\n    if (content) {\n      this.parseData(content).forEach((x) => {\n        tabs += this.generateTabButton(x.fileName);\n        views += this.generateAsyncCodeView(x.url);\n      });\n    } else {\n      tabs = '';\n    }\n\n    return { tabs, views };\n  }\n\n  private parseComponentTags(token: IMarkdownItToken): { tag: string, height?: string } {\n    if (!this.isNgComponent(token)) {\n      return { tag: '', height: '' };\n    }\n\n    let cleanedInput = token.info.replace(/ng-component\\s*/, '');\n\n    const tagMatch = cleanedInput.match(/<([a-zA-Z0-9-]+)>.*<\\/\\1>/);\n    const heightMatch = cleanedInput.match(/\\[height\\]=\"(\\d+)\"/);\n\n    if (!tagMatch) {\n      throw new Error(\"Invalid input: no valid tag found\");\n    }\n\n    const tag = tagMatch[ 0 ];\n    const height = heightMatch ? heightMatch[ 1 ] : undefined;\n\n    return { tag, height };\n  }\n\n  private parseData(data: string): { fileName: string, url: string }[] {\n    return data.split('\\n').map(this.extractFileData).filter(Boolean) as { fileName: string, url: string }[];\n  }\n\n  private extractFileData(line: string): { fileName: string, url: string } | null {\n    const match = line.match(/\\[(.+?)\\] <<< (.+)/);\n    return match ? { fileName: match[ 1 ], url: match[ 2 ] } : null;\n  }\n\n  private openingExampleGroupHTML(data: { tabs: string, views: string }): string {\n    return `<div class=\"f-code-group\">${ this.groupTabsHTML(data.tabs) }${ this.groupBodyHTML(data.views) }`;\n  }\n\n  private groupTabsHTML(content: string): string {\n    let result = `<div class=\"f-code-group-tabs\">${ content }</div>`;\n    if (!content) {\n      result = '';\n    }\n    return result;\n  }\n\n  private generateTabButton(content: string): string {\n    return `<button class=\"f-tab-button\">${ content }</button>`;\n  }\n\n  private groupBodyHTML(content: string): string {\n    return `<div class=\"f-code-group-body\">${ content }`;\n  }\n\n  private generateExampleView(content: { tag: string, height?: string }): string {\n    let height = '';\n    if (content.height) {\n      height = `style=\"height: ${ content.height }px\"`;\n    }\n    return `<div class=\"f-example-view\" ${ height }>${ content.tag }</div>`;\n  }\n\n  private generateAsyncCodeView(content: string): string {\n    return `<div class=\"f-async-code-view\">${ content }</div>`;\n  }\n\n  private closingExampleGroupHTML(): string {\n    return `</div></div>\\n`;\n  }\n}\n"]}

package/esm2022/lib/f-page/f-markdown/domain/markdown/parse-markdown/parse-preview-group.mjs

@@ -0,0 +1,49 @@
+import container from 'markdown-it-container';
+import { EMarkdownContainerType } from './e-markdown-container-type';
+import { getContent } from '../utils';
+export class ParsePreviewGroup {
+    constructor(navigation) {
+        this.navigation = navigation;
+    }
+    render() {
+        return [container, EMarkdownContainerType.PREVIEW_GROUP, {
+                render: (tokens, index) => {
+                    if (this.isOpeningToken(tokens, index)) {
+                        return this.getGroupsHTML(this.generateData(tokens, index));
+                    }
+                    return '';
+                }
+            }];
+    }
+    isOpeningToken(tokens, index) {
+        return tokens[index].nesting === 1;
+    }
+    generateData(tokens, index) {
+        const groups = [];
+        this.parseData(getContent(tokens, index, EMarkdownContainerType.PREVIEW_GROUP) || '').forEach((x) => {
+            const group = this.navigation.find((g) => g.text === x);
+            if (group) {
+                groups.push(group);
+            }
+        });
+        return groups;
+    }
+    parseData(data) {
+        return data.split('\n').map(this.extractFileData).filter(Boolean);
+    }
+    extractFileData(line) {
+        const match = line.match(/\[(.+?)\]/);
+        return match ? match[1] : null;
+    }
+    getGroupsHTML(groups) {
+        return (groups || []).map((x) => {
+            return `<h2>${x.text}</h2><div class="f-preview-group">${this.getItemsHTML(x)}</div>`;
+        }).join('');
+    }
+    getItemsHTML(group) {
+        return group.items.map((item) => {
+            return `<f-preview data-group="${group.text}" data-item="${item.link}"></f-preview>`;
+        }).join('');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/f-page/f-markdown/domain/markdown/utils/get-content.mjs

@@ -0,0 +1,17 @@
+export function getContent(tokens, index, eContainerType) {
+    let result;
+    for (let i = index + 1; i < tokens.length; i++) {
+        if (tokens[i].type === `container_${eContainerType}_close`) {
+            break;
+        }
+        if (isInlineToken(tokens[i])) {
+            result = tokens[i].content;
+            break;
+        }
+    }
+    return result;
+}
+function isInlineToken(token) {
+    return token.type === 'inline' && !token.tag;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2RvbWFpbi9tYXJrZG93bi91dGlscy9nZXQtY29udGVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFFQSxNQUFNLFVBQVUsVUFBVSxDQUFDLE1BQTBCLEVBQUUsS0FBYSxFQUFFLGNBQXNDO0lBQzFHLElBQUksTUFBMEIsQ0FBQztJQUUvQixLQUFLLElBQUksQ0FBQyxHQUFHLEtBQUssR0FBRyxDQUFDLEVBQUUsQ0FBQyxHQUFHLE1BQU0sQ0FBQyxNQUFNLEVBQUUsQ0FBQyxFQUFFLEVBQUUsQ0FBQztRQUMvQyxJQUFJLE1BQU0sQ0FBRSxDQUFDLENBQUUsQ0FBQyxJQUFJLEtBQUssYUFBYyxjQUFlLFFBQVEsRUFBRSxDQUFDO1lBQy9ELE1BQU07UUFDUixDQUFDO1FBQ0QsSUFBSSxhQUFhLENBQUMsTUFBTSxDQUFFLENBQUMsQ0FBRSxDQUFDLEVBQUUsQ0FBQztZQUMvQixNQUFNLEdBQUcsTUFBTSxDQUFFLENBQUMsQ0FBRSxDQUFDLE9BQU8sQ0FBQztZQUM3QixNQUFNO1FBQ1IsQ0FBQztJQUNILENBQUM7SUFDRCxPQUFPLE1BQU0sQ0FBQztBQUNoQixDQUFDO0FBRUQsU0FBUyxhQUFhLENBQUMsS0FBdUI7SUFDNUMsT0FBTyxLQUFLLENBQUMsSUFBSSxLQUFLLFFBQVEsSUFBSSxDQUFDLEtBQUssQ0FBQyxHQUFHLENBQUM7QUFDL0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVNYXJrZG93bkNvbnRhaW5lclR5cGUsIElNYXJrZG93bkl0VG9rZW4gfSBmcm9tICcuLi9wYXJzZS1tYXJrZG93bic7XG5cbmV4cG9ydCBmdW5jdGlvbiBnZXRDb250ZW50KHRva2VuczogSU1hcmtkb3duSXRUb2tlbltdLCBpbmRleDogbnVtYmVyLCBlQ29udGFpbmVyVHlwZTogRU1hcmtkb3duQ29udGFpbmVyVHlwZSk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIGxldCByZXN1bHQ6IHN0cmluZyB8IHVuZGVmaW5lZDtcblxuICBmb3IgKGxldCBpID0gaW5kZXggKyAxOyBpIDwgdG9rZW5zLmxlbmd0aDsgaSsrKSB7XG4gICAgaWYgKHRva2Vuc1sgaSBdLnR5cGUgPT09IGBjb250YWluZXJfJHsgZUNvbnRhaW5lclR5cGUgfV9jbG9zZWApIHtcbiAgICAgIGJyZWFrO1xuICAgIH1cbiAgICBpZiAoaXNJbmxpbmVUb2tlbih0b2tlbnNbIGkgXSkpIHtcbiAgICAgIHJlc3VsdCA9IHRva2Vuc1sgaSBdLmNvbnRlbnQ7XG4gICAgICBicmVhaztcbiAgICB9XG4gIH1cbiAgcmV0dXJuIHJlc3VsdDtcbn1cblxuZnVuY3Rpb24gaXNJbmxpbmVUb2tlbih0b2tlbjogSU1hcmtkb3duSXRUb2tlbik6IGJvb2xlYW4ge1xuICByZXR1cm4gdG9rZW4udHlwZSA9PT0gJ2lubGluZScgJiYgIXRva2VuLnRhZztcbn1cbiJdfQ==

package/esm2022/lib/f-page/f-markdown/domain/markdown/utils/index.mjs

@@ -0,0 +1,2 @@
+export * from './get-content';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2RvbWFpbi9tYXJrZG93bi91dGlscy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGVBQWUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ2V0LWNvbnRlbnQnO1xuIl19

package/esm2022/lib/f-page/f-markdown/f-markdown-renderer.component.mjs

@@ -0,0 +1,80 @@
+import { ChangeDetectionStrategy, Component, ElementRef, HostListener, inject, } from '@angular/core';
+import { debounceTime, startWith, Subscription, switchMap } from 'rxjs';
+import { FScrollableService } from '../../f-scrollable-container/f-scrollable.service';
+import { catchError, tap } from 'rxjs/operators';
+import { ActivatedRoute, Router } from '@angular/router';
+import { HandleDynamicComponentsHandler, HandleDynamicComponentsRequest, HandleParsedContainersHandler, HandleParsedContainersRequest, HighlightService, MarkdownService } from './domain';
+import { FEnvironmentService, HandleNavigationLinksHandler, HandleNavigationLinksRequest } from '../../domain';
+import { FMarkdownFooterComponent } from '../f-markdown-footer';
+import * as i0 from "@angular/core";
+export class FMarkdownRendererComponent {
+    constructor(injector, changeDetectorRef) {
+        this.injector = injector;
+        this.changeDetectorRef = changeDetectorRef;
+        this.subscriptions$ = new Subscription();
+        this.hostElement = inject(ElementRef).nativeElement;
+        this.fScrollableService = inject(FScrollableService);
+        this.fContainersHandler = inject(HandleParsedContainersHandler);
+        this.fDynamicComponentsHandler = inject(HandleDynamicComponentsHandler);
+        this.isMarkdownChanged = false;
+    }
+    ngOnInit() {
+        this.subscriptions$.add(this.subscribeOnRouteChanges());
+    }
+    subscribeOnRouteChanges() {
+        return this.getRouterEvents().pipe(startWith(null), debounceTime(50), switchMap(() => this.injector.get(MarkdownService).parse(this.injector.get(FEnvironmentService).getMarkdownUrl(this.markdownPath))), tap((x) => this.renderMarkdown(x)), catchError((e, data) => data)).subscribe();
+    }
+    getRouterEvents() {
+        return this.injector.get(Router).events;
+    }
+    get markdownPath() {
+        return this.injector.get(ActivatedRoute).snapshot.url.map((x) => x.path).join('/');
+    }
+    renderMarkdown(value) {
+        this.value = value;
+        this.isMarkdownChanged = true;
+        this.changeDetectorRef.markForCheck();
+    }
+    ngAfterViewChecked() {
+        if (this.isMarkdownChanged) {
+            this.isMarkdownChanged = false;
+            this.fScrollableService.setOnPageNavigation(this.hostElement);
+            this.fContainersHandler.handle(new HandleParsedContainersRequest(this.hostElement));
+            this.fDynamicComponentsHandler.handle(new HandleDynamicComponentsRequest(this.hostElement));
+        }
+    }
+    onDocumentClick(event) {
+        this.injector.get(HandleNavigationLinksHandler).handle(new HandleNavigationLinksRequest(event));
+    }
+    ngOnDestroy() {
+        this.fContainersHandler.dispose();
+        this.fDynamicComponentsHandler.dispose();
+        this.subscriptions$.unsubscribe();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FMarkdownRendererComponent, deps: [{ token: i0.Injector }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FMarkdownRendererComponent, isStandalone: true, selector: "f-markdown-renderer", host: { listeners: { "click": "onDocumentClick($event)" }, classAttribute: "m-render" }, providers: [
+            MarkdownService,
+            HighlightService,
+            HandleNavigationLinksHandler,
+            HandleParsedContainersHandler,
+            HandleDynamicComponentsHandler
+        ], ngImport: i0, template: "<div [innerHTML]=\"value\"></div>\n<footer f-markdown-footer></footer>\n", styles: [":host{display:block;width:100%}@media (min-width: 1280px){:host{width:calc(100% - var(--on-page-navigation-width) - var(--page-padding))}}\n"], dependencies: [{ kind: "component", type: FMarkdownFooterComponent, selector: "footer [f-markdown-footer]" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FMarkdownRendererComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'f-markdown-renderer', standalone: true, changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        MarkdownService,
+                        HighlightService,
+                        HandleNavigationLinksHandler,
+                        HandleParsedContainersHandler,
+                        HandleDynamicComponentsHandler
+                    ], imports: [
+                        FMarkdownFooterComponent
+                    ], host: {
+                        class: 'm-render'
+                    }, template: "<div [innerHTML]=\"value\"></div>\n<footer f-markdown-footer></footer>\n", styles: [":host{display:block;width:100%}@media (min-width: 1280px){:host{width:calc(100% - var(--on-page-navigation-width) - var(--page-padding))}}\n"] }]
+        }], ctorParameters: () => [{ type: i0.Injector }, { type: i0.ChangeDetectorRef }], propDecorators: { onDocumentClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"f-markdown-renderer.component.js","sourceRoot":"","sources":["../../../../../../projects/m-render/src/lib/f-page/f-markdown/f-markdown-renderer.component.ts","../../../../../../projects/m-render/src/lib/f-page/f-markdown/f-markdown-renderer.component.html"],"names":[],"mappings":"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","sourcesContent":["import {\n  AfterViewChecked,\n  ChangeDetectionStrategy, ChangeDetectorRef,\n  Component, ElementRef, HostListener, inject, Injector, OnDestroy, OnInit,\n} from '@angular/core';\nimport {\n  debounceTime,\n  Observable,\n  startWith,\n  Subscription,\n  switchMap\n} from 'rxjs';\nimport { SafeHtml } from '@angular/platform-browser';\nimport { FScrollableService } from '../../f-scrollable-container/f-scrollable.service';\nimport { catchError, tap } from 'rxjs/operators';\nimport { ActivatedRoute, Router } from '@angular/router';\nimport {\n  HandleDynamicComponentsHandler,\n  HandleDynamicComponentsRequest,\n  HandleParsedContainersHandler,\n  HandleParsedContainersRequest, HighlightService,\n  MarkdownService\n} from './domain';\nimport {\n  FEnvironmentService,\n  HandleNavigationLinksHandler,\n  HandleNavigationLinksRequest\n} from '../../domain';\nimport { FMarkdownFooterComponent } from '../f-markdown-footer';\n\n@Component({\n  selector: 'f-markdown-renderer',\n  templateUrl: './f-markdown-renderer.component.html',\n  styleUrls: [ './f-markdown-renderer.component.scss' ],\n  standalone: true,\n  changeDetection: ChangeDetectionStrategy.OnPush,\n  providers: [\n    MarkdownService,\n    HighlightService,\n    HandleNavigationLinksHandler,\n    HandleParsedContainersHandler,\n    HandleDynamicComponentsHandler\n  ],\n  imports: [\n    FMarkdownFooterComponent\n  ],\n  host: {\n    class: 'm-render'\n  }\n})\nexport class FMarkdownRendererComponent implements OnInit, AfterViewChecked, OnDestroy {\n\n  private subscriptions$: Subscription = new Subscription();\n\n  protected value: SafeHtml | undefined;\n\n  private hostElement = inject(ElementRef).nativeElement;\n\n  private fScrollableService = inject(FScrollableService);\n  private fContainersHandler = inject(HandleParsedContainersHandler);\n  private fDynamicComponentsHandler = inject(HandleDynamicComponentsHandler);\n\n  private isMarkdownChanged: boolean = false;\n\n  constructor(\n    private injector: Injector,\n    private changeDetectorRef: ChangeDetectorRef\n  ) {\n  }\n\n  public ngOnInit(): void {\n    this.subscriptions$.add(this.subscribeOnRouteChanges());\n  }\n\n  private subscribeOnRouteChanges(): Subscription {\n    return this.getRouterEvents().pipe(\n      startWith(null), debounceTime(50),\n      switchMap(() => this.injector.get(MarkdownService).parse(\n        this.injector.get(FEnvironmentService).getMarkdownUrl(this.markdownPath)\n      )),\n      tap((x) => this.renderMarkdown(x)),\n      catchError((e, data) => data)\n    ).subscribe();\n  }\n\n  private getRouterEvents(): Observable<any> {\n    return this.injector.get(Router).events;\n  }\n\n  private get markdownPath(): string {\n    return this.injector.get(ActivatedRoute).snapshot.url.map((x) => x.path).join('/');\n  }\n\n  private renderMarkdown(value: SafeHtml): void {\n    this.value = value;\n    this.isMarkdownChanged = true;\n    this.changeDetectorRef.markForCheck();\n  }\n\n  public ngAfterViewChecked(): void {\n    if (this.isMarkdownChanged) {\n      this.isMarkdownChanged = false;\n      this.fScrollableService.setOnPageNavigation(this.hostElement);\n      this.fContainersHandler.handle(new HandleParsedContainersRequest(this.hostElement));\n      this.fDynamicComponentsHandler.handle(new HandleDynamicComponentsRequest(this.hostElement));\n    }\n  }\n\n  @HostListener('click', [ '$event' ])\n  public onDocumentClick(event: MouseEvent): void {\n    this.injector.get(HandleNavigationLinksHandler).handle(new HandleNavigationLinksRequest(event));\n  }\n\n  public ngOnDestroy(): void {\n    this.fContainersHandler.dispose();\n    this.fDynamicComponentsHandler.dispose();\n    this.subscriptions$.unsubscribe();\n  }\n}\n\n","<div [innerHTML]=\"value\"></div>\n<footer f-markdown-footer></footer>\n"]}

package/esm2022/lib/f-page/f-markdown/index.mjs

@@ -0,0 +1,3 @@
+export * from './domain';
+export * from './f-markdown-renderer.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsVUFBVSxDQUFDO0FBRXpCLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2RvbWFpbic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1tYXJrZG93bi1yZW5kZXJlci5jb21wb25lbnQnO1xuXG4iXX0=

package/esm2022/lib/f-page/f-markdown-footer/domain/features/get-previous-next-page-navigation/get-previous-next-page-navigation.handler.mjs

@@ -0,0 +1,36 @@
+import { GetPreviousNextPageNavigationResponse } from './get-previous-next-page-navigation.response';
+export class GetPreviousNextPageNavigationHandler {
+    constructor(fEnvironmentService) {
+        this.fEnvironmentService = fEnvironmentService;
+    }
+    handle(request) {
+        let previous = undefined;
+        let next = undefined;
+        this.fEnvironmentService.getNavigation().forEach((group, groupIndex) => {
+            (group.items || []).forEach((item, index) => {
+                if (item.link === request.currentLink) {
+                    if (index > 0) {
+                        previous = { ...group.items[index - 1] };
+                    }
+                    else {
+                        if (groupIndex > 0) {
+                            const previousGroup = this.fEnvironmentService.getNavigation()[groupIndex - 1];
+                            previous = { ...previousGroup.items[previousGroup.items.length - 1] };
+                        }
+                    }
+                    if (index < group.items.length - 1) {
+                        next = { ...group.items[index + 1] };
+                    }
+                    else {
+                        if (groupIndex < this.fEnvironmentService.getNavigation().length - 1) {
+                            const nextGroup = this.fEnvironmentService.getNavigation()[groupIndex + 1];
+                            next = { ...nextGroup.items[0] };
+                        }
+                    }
+                }
+            });
+        });
+        return new GetPreviousNextPageNavigationResponse(previous, next);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/f-page/f-markdown-footer/domain/features/get-previous-next-page-navigation/get-previous-next-page-navigation.request.mjs

@@ -0,0 +1,6 @@
+export class GetPreviousNextPageNavigationRequest {
+    constructor(currentLink) {
+        this.currentLink = currentLink;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXByZXZpb3VzLW5leHQtcGFnZS1uYXZpZ2F0aW9uLnJlcXVlc3QuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9kb21haW4vZmVhdHVyZXMvZ2V0LXByZXZpb3VzLW5leHQtcGFnZS1uYXZpZ2F0aW9uL2dldC1wcmV2aW91cy1uZXh0LXBhZ2UtbmF2aWdhdGlvbi5yZXF1ZXN0LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE1BQU0sT0FBTyxvQ0FBb0M7SUFFL0MsWUFDUyxXQUFtQjtRQUFuQixnQkFBVyxHQUFYLFdBQVcsQ0FBUTtJQUN6QixDQUFDO0NBQ0wiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgR2V0UHJldmlvdXNOZXh0UGFnZU5hdmlnYXRpb25SZXF1ZXN0IHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgY3VycmVudExpbms6IHN0cmluZ1xuICApIHt9XG59XG4iXX0=

package/esm2022/lib/f-page/f-markdown-footer/domain/features/get-previous-next-page-navigation/get-previous-next-page-navigation.response.mjs

@@ -0,0 +1,7 @@
+export class GetPreviousNextPageNavigationResponse {
+    constructor(previousLink, nextLink) {
+        this.previousLink = previousLink;
+        this.nextLink = nextLink;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LXByZXZpb3VzLW5leHQtcGFnZS1uYXZpZ2F0aW9uLnJlc3BvbnNlLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbS1yZW5kZXIvc3JjL2xpYi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZG9tYWluL2ZlYXR1cmVzL2dldC1wcmV2aW91cy1uZXh0LXBhZ2UtbmF2aWdhdGlvbi9nZXQtcHJldmlvdXMtbmV4dC1wYWdlLW5hdmlnYXRpb24ucmVzcG9uc2UudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxPQUFPLHFDQUFxQztJQUVoRCxZQUNTLFlBQW1DLEVBQ25DLFFBQStCO1FBRC9CLGlCQUFZLEdBQVosWUFBWSxDQUF1QjtRQUNuQyxhQUFRLEdBQVIsUUFBUSxDQUF1QjtJQUd4QyxDQUFDO0NBQ0YiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJUGFnZUxpbmsgfSBmcm9tICcuLi8uLi9pLXBhZ2UtbGluayc7XG5cbmV4cG9ydCBjbGFzcyBHZXRQcmV2aW91c05leHRQYWdlTmF2aWdhdGlvblJlc3BvbnNlIHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgcHJldmlvdXNMaW5rOiBJUGFnZUxpbmsgfCB1bmRlZmluZWQsXG4gICAgcHVibGljIG5leHRMaW5rOiBJUGFnZUxpbmsgfCB1bmRlZmluZWRcbiAgKSB7XG5cbiAgfVxufVxuIl19

package/esm2022/lib/f-page/f-markdown-footer/domain/features/get-previous-next-page-navigation/index.mjs

@@ -0,0 +1,4 @@
+export * from './get-previous-next-page-navigation.handler';
+export * from './get-previous-next-page-navigation.request';
+export * from './get-previous-next-page-navigation.response';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9kb21haW4vZmVhdHVyZXMvZ2V0LXByZXZpb3VzLW5leHQtcGFnZS1uYXZpZ2F0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsNkNBQTZDLENBQUM7QUFFNUQsY0FBYyw2Q0FBNkMsQ0FBQztBQUU1RCxjQUFjLDhDQUE4QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9nZXQtcHJldmlvdXMtbmV4dC1wYWdlLW5hdmlnYXRpb24uaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZ2V0LXByZXZpb3VzLW5leHQtcGFnZS1uYXZpZ2F0aW9uLnJlcXVlc3QnO1xuXG5leHBvcnQgKiBmcm9tICcuL2dldC1wcmV2aW91cy1uZXh0LXBhZ2UtbmF2aWdhdGlvbi5yZXNwb25zZSc7XG4iXX0=

package/esm2022/lib/f-page/f-markdown-footer/domain/features/index.mjs

@@ -0,0 +1,2 @@
+export * from './get-previous-next-page-navigation';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9kb21haW4vZmVhdHVyZXMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQ0FBcUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ2V0LXByZXZpb3VzLW5leHQtcGFnZS1uYXZpZ2F0aW9uJztcbiJdfQ==

package/esm2022/lib/f-page/f-markdown-footer/domain/i-page-link.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaS1wYWdlLWxpbmsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9kb21haW4vaS1wYWdlLWxpbmsudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCBpbnRlcmZhY2UgSVBhZ2VMaW5rIHtcblxuICB0ZXh0Pzogc3RyaW5nO1xuXG4gIGxpbms/OiBzdHJpbmc7XG59XG4iXX0=

package/esm2022/lib/f-page/f-markdown-footer/domain/index.mjs

@@ -0,0 +1,3 @@
+export * from './features';
+export * from './i-page-link';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9kb21haW4vaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxZQUFZLENBQUM7QUFFM0IsY0FBYyxlQUFlLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2ZlYXR1cmVzJztcblxuZXhwb3J0ICogZnJvbSAnLi9pLXBhZ2UtbGluayc7XG4iXX0=

package/esm2022/lib/f-page/f-markdown-footer/f-footer-edit-information/f-footer-edit-information.component.mjs

@@ -0,0 +1,11 @@
+import { ChangeDetectionStrategy, Component, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FFooterEditInformationComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterEditInformationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FFooterEditInformationComponent, isStandalone: true, selector: "f-footer-edit-information", ngImport: i0, template: "<ng-content></ng-content>\n", styles: [":host{padding-bottom:18px}@media (min-width: 640px){:host{display:flex;justify-content:space-between;align-items:center;padding-bottom:14px}}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterEditInformationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'f-footer-edit-information', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "<ng-content></ng-content>\n", styles: [":host{padding-bottom:18px}@media (min-width: 640px){:host{display:flex;justify-content:space-between;align-items:center;padding-bottom:14px}}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24uY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbS1yZW5kZXIvc3JjL2xpYi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCx1QkFBdUIsRUFDdkIsU0FBUyxHQUNWLE1BQU0sZUFBZSxDQUFDOztBQVN2QixNQUFNLE9BQU8sK0JBQStCOytHQUEvQiwrQkFBK0I7bUdBQS9CLCtCQUErQixxRkNaNUMsNkJBQ0E7OzRGRFdhLCtCQUErQjtrQkFQM0MsU0FBUzsrQkFDRSwyQkFBMkIsbUJBR3BCLHVCQUF1QixDQUFDLE1BQU0sY0FDbkMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICBDb21wb25lbnQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICdmLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24uY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsgJy4vZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi5jb21wb25lbnQuc2NzcycgXSxcbiAgY2hhbmdlRGV0ZWN0aW9uOiBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneS5PblB1c2gsXG4gIHN0YW5kYWxvbmU6IHRydWVcbn0pXG5leHBvcnQgY2xhc3MgRkZvb3RlckVkaXRJbmZvcm1hdGlvbkNvbXBvbmVudCB7XG5cbn1cbiIsIjxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiJdfQ==

package/esm2022/lib/f-page/f-markdown-footer/f-footer-edit-information/f-footer-edit-link/f-footer-edit-link.component.mjs

@@ -0,0 +1,11 @@
+import { ChangeDetectionStrategy, Component, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FFooterEditLinkComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterEditLinkComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FFooterEditLinkComponent, isStandalone: true, selector: "a[f-footer-edit-link]", ngImport: i0, template: "<span class=\"edit-link-icon f-icon edit\"></span>\n<ng-content></ng-content>\n", styles: [":host{display:flex;align-items:center;border:0;line-height:32px;font-size:14px;font-weight:500;color:var(--primary-1);cursor:pointer}:host .edit-link-icon{margin-right:8px;width:14px;height:14px;color:inherit}:host:hover{color:var(--primary-2)}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterEditLinkComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'a[f-footer-edit-link]', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "<span class=\"edit-link-icon f-icon edit\"></span>\n<ng-content></ng-content>\n", styles: [":host{display:flex;align-items:center;border:0;line-height:32px;font-size:14px;font-weight:500;color:var(--primary-1);cursor:pointer}:host .edit-link-icon{margin-right:8px;width:14px;height:14px;color:inherit}:host:hover{color:var(--primary-2)}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItZWRpdC1saW5rLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1wYWdlL2YtbWFya2Rvd24tZm9vdGVyL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24vZi1mb290ZXItZWRpdC1saW5rL2YtZm9vdGVyLWVkaXQtbGluay5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWVkaXQtbGluay9mLWZvb3Rlci1lZGl0LWxpbmsuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixTQUFTLEdBQ1YsTUFBTSxlQUFlLENBQUM7O0FBU3ZCLE1BQU0sT0FBTyx3QkFBd0I7K0dBQXhCLHdCQUF3QjttR0FBeEIsd0JBQXdCLGlGQ1pyQyxpRkFFQTs7NEZEVWEsd0JBQXdCO2tCQVBwQyxTQUFTOytCQUNFLHVCQUF1QixtQkFHaEIsdUJBQXVCLENBQUMsTUFBTSxjQUNuQyxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENvbXBvbmVudCxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2FbZi1mb290ZXItZWRpdC1saW5rXScsXG4gIHRlbXBsYXRlVXJsOiAnLi9mLWZvb3Rlci1lZGl0LWxpbmsuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsgJy4vZi1mb290ZXItZWRpdC1saW5rLmNvbXBvbmVudC5zY3NzJyBdLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBGRm9vdGVyRWRpdExpbmtDb21wb25lbnQge1xuXG59XG4iLCI8c3BhbiBjbGFzcz1cImVkaXQtbGluay1pY29uIGYtaWNvbiBlZGl0XCI+PC9zcGFuPlxuPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuIl19

package/esm2022/lib/f-page/f-markdown-footer/f-footer-edit-information/f-footer-edit-link/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-footer-edit-link.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWVkaXQtbGluay9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mLWZvb3Rlci1lZGl0LWxpbmsuY29tcG9uZW50JztcblxuIl19

package/esm2022/lib/f-page/f-markdown-footer/f-footer-edit-information/f-footer-last-updated/f-footer-last-updated.component.mjs

@@ -0,0 +1,11 @@
+import { ChangeDetectionStrategy, Component, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FFooterLastUpdatedComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterLastUpdatedComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FFooterLastUpdatedComponent, isStandalone: true, selector: "f-footer-last-updated", ngImport: i0, template: "<ng-content></ng-content>\n", styles: [":host{line-height:24px;font-size:14px;font-weight:500;color:var(--secondary-text)}@media (min-width: 640px){:host{line-height:32px;font-size:14px;font-weight:500}}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterLastUpdatedComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'f-footer-last-updated', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "<ng-content></ng-content>\n", styles: [":host{line-height:24px;font-size:14px;font-weight:500;color:var(--secondary-text)}@media (min-width: 640px){:host{line-height:32px;font-size:14px;font-weight:500}}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItbGFzdC11cGRhdGVkLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1wYWdlL2YtbWFya2Rvd24tZm9vdGVyL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24vZi1mb290ZXItbGFzdC11cGRhdGVkL2YtZm9vdGVyLWxhc3QtdXBkYXRlZC5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWxhc3QtdXBkYXRlZC9mLWZvb3Rlci1sYXN0LXVwZGF0ZWQuY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixTQUFTLEdBQ1YsTUFBTSxlQUFlLENBQUM7O0FBU3ZCLE1BQU0sT0FBTywyQkFBMkI7K0dBQTNCLDJCQUEyQjttR0FBM0IsMkJBQTJCLGlGQ1p4Qyw2QkFDQTs7NEZEV2EsMkJBQTJCO2tCQVB2QyxTQUFTOytCQUNFLHVCQUF1QixtQkFHaEIsdUJBQXVCLENBQUMsTUFBTSxjQUNuQyxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENvbXBvbmVudCxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2YtZm9vdGVyLWxhc3QtdXBkYXRlZCcsXG4gIHRlbXBsYXRlVXJsOiAnLi9mLWZvb3Rlci1sYXN0LXVwZGF0ZWQuY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsgJy4vZi1mb290ZXItbGFzdC11cGRhdGVkLmNvbXBvbmVudC5zY3NzJyBdLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBGRm9vdGVyTGFzdFVwZGF0ZWRDb21wb25lbnQge1xuXG59XG4iLCI8bmctY29udGVudD48L25nLWNvbnRlbnQ+XG4iXX0=

package/esm2022/lib/f-page/f-markdown-footer/f-footer-edit-information/f-footer-last-updated/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-footer-last-updated.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWxhc3QtdXBkYXRlZC9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG1DQUFtQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mLWZvb3Rlci1sYXN0LXVwZGF0ZWQuY29tcG9uZW50JztcblxuIl19

package/esm2022/lib/f-page/f-markdown-footer/f-footer-edit-information/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-footer-edit-information.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsdUNBQXVDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24uY29tcG9uZW50JztcblxuIl19

package/esm2022/lib/f-page/f-markdown-footer/f-footer-navigation/f-footer-navigation-button/f-footer-navigation-button.component.mjs

@@ -0,0 +1,17 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FFooterNavigationButtonComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterNavigationButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FFooterNavigationButtonComponent, isStandalone: true, selector: "a[f-footer-navigation-button]", inputs: { description: "description", link: "link" }, ngImport: i0, template: "<span class=\"description\">{{ description }}</span>\n<span class=\"page-title\">{{ link.text }}</span>\n", styles: [":host{display:block;border:1px solid var(--divider-color);border-radius:2px;padding:12px 16px;flex:1;max-width:50%;min-width:260px;text-decoration:none!important;cursor:pointer;pointer-events:all}:host:hover{border-color:var(--dark-divider-color)}:host:active{border-color:var(--primary-1)}:host.next{margin-left:auto;text-align:right}:host .description{display:block;line-height:20px;font-size:12px;font-weight:500;color:var(--secondary-text);pointer-events:none}:host .page-title{display:block;line-height:20px;font-size:14px;font-weight:500;color:var(--primary-1);pointer-events:none}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterNavigationButtonComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'a[f-footer-navigation-button]', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "<span class=\"description\">{{ description }}</span>\n<span class=\"page-title\">{{ link.text }}</span>\n", styles: [":host{display:block;border:1px solid var(--divider-color);border-radius:2px;padding:12px 16px;flex:1;max-width:50%;min-width:260px;text-decoration:none!important;cursor:pointer;pointer-events:all}:host:hover{border-color:var(--dark-divider-color)}:host:active{border-color:var(--primary-1)}:host.next{margin-left:auto;text-align:right}:host .description{display:block;line-height:20px;font-size:12px;font-weight:500;color:var(--secondary-text);pointer-events:none}:host .page-title{display:block;line-height:20px;font-size:14px;font-weight:500;color:var(--primary-1);pointer-events:none}\n"] }]
+        }], propDecorators: { description: [{
+                type: Input,
+                args: [{ required: true }]
+            }], link: [{
+                type: Input,
+                args: [{ required: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItbmF2aWdhdGlvbi1idXR0b24uY29tcG9uZW50LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbS1yZW5kZXIvc3JjL2xpYi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItbmF2aWdhdGlvbi9mLWZvb3Rlci1uYXZpZ2F0aW9uLWJ1dHRvbi9mLWZvb3Rlci1uYXZpZ2F0aW9uLWJ1dHRvbi5jb21wb25lbnQudHMiLCIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1uYXZpZ2F0aW9uL2YtZm9vdGVyLW5hdmlnYXRpb24tYnV0dG9uL2YtZm9vdGVyLW5hdmlnYXRpb24tYnV0dG9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCx1QkFBdUIsRUFDdkIsU0FBUyxFQUFFLEtBQUssR0FDakIsTUFBTSxlQUFlLENBQUM7O0FBVXZCLE1BQU0sT0FBTyxnQ0FBZ0M7K0dBQWhDLGdDQUFnQzttR0FBaEMsZ0NBQWdDLCtJQ2I3QywyR0FFQTs7NEZEV2EsZ0NBQWdDO2tCQVA1QyxTQUFTOytCQUNFLCtCQUErQixtQkFHeEIsdUJBQXVCLENBQUMsTUFBTSxjQUNuQyxJQUFJOzhCQUtULFdBQVc7c0JBRGpCLEtBQUs7dUJBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFO2dCQUlsQixJQUFJO3NCQURWLEtBQUs7dUJBQUMsRUFBRSxRQUFRLEVBQUUsSUFBSSxFQUFFIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENvbXBvbmVudCwgSW5wdXQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuaW1wb3J0IHsgSVBhZ2VMaW5rIH0gZnJvbSAnLi4vLi4vZG9tYWluJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYVtmLWZvb3Rlci1uYXZpZ2F0aW9uLWJ1dHRvbl0nLFxuICB0ZW1wbGF0ZVVybDogJy4vZi1mb290ZXItbmF2aWdhdGlvbi1idXR0b24uY29tcG9uZW50Lmh0bWwnLFxuICBzdHlsZVVybHM6IFsgJy4vZi1mb290ZXItbmF2aWdhdGlvbi1idXR0b24uY29tcG9uZW50LnNjc3MnIF0sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIEZGb290ZXJOYXZpZ2F0aW9uQnV0dG9uQ29tcG9uZW50IHtcblxuICBASW5wdXQoeyByZXF1aXJlZDogdHJ1ZSB9KVxuICBwdWJsaWMgZGVzY3JpcHRpb246IHN0cmluZyB8IHVuZGVmaW5lZDtcblxuICBASW5wdXQoeyByZXF1aXJlZDogdHJ1ZSB9KVxuICBwdWJsaWMgbGluayE6IElQYWdlTGluaztcbn1cbiIsIjxzcGFuIGNsYXNzPVwiZGVzY3JpcHRpb25cIj57eyBkZXNjcmlwdGlvbiB9fTwvc3Bhbj5cbjxzcGFuIGNsYXNzPVwicGFnZS10aXRsZVwiPnt7IGxpbmsudGV4dCB9fTwvc3Bhbj5cbiJdfQ==

package/esm2022/lib/f-page/f-markdown-footer/f-footer-navigation/f-footer-navigation-button/index.mjs

@@ -0,0 +1,2 @@
+export * from './f-footer-navigation-button.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1uYXZpZ2F0aW9uL2YtZm9vdGVyLW5hdmlnYXRpb24tYnV0dG9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsd0NBQXdDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2YtZm9vdGVyLW5hdmlnYXRpb24tYnV0dG9uLmNvbXBvbmVudCc7XG5cbiJdfQ==

package/esm2022/lib/f-page/f-markdown-footer/f-footer-navigation/f-footer-navigation.component.mjs

@@ -0,0 +1,11 @@
+import { ChangeDetectionStrategy, Component, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FFooterNavigationComponent {
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterNavigationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: FFooterNavigationComponent, isStandalone: true, selector: "nav[f-footer-navigation]", ngImport: i0, template: "<ng-content></ng-content>\n", styles: [":host{border-top:1px solid var(--divider-color);padding-top:24px;display:flex;justify-content:flex-start;align-items:flex-start;flex-wrap:wrap;gap:16px}\n"], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: FFooterNavigationComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'nav[f-footer-navigation]', changeDetection: ChangeDetectionStrategy.OnPush, standalone: true, template: "<ng-content></ng-content>\n", styles: [":host{border-top:1px solid var(--divider-color);padding-top:24px;display:flex;justify-content:flex-start;align-items:flex-start;flex-wrap:wrap;gap:16px}\n"] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItbmF2aWdhdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1uYXZpZ2F0aW9uL2YtZm9vdGVyLW5hdmlnYXRpb24uY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbS1yZW5kZXIvc3JjL2xpYi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItbmF2aWdhdGlvbi9mLWZvb3Rlci1uYXZpZ2F0aW9uLmNvbXBvbmVudC5odG1sIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCx1QkFBdUIsRUFDdkIsU0FBUyxHQUNWLE1BQU0sZUFBZSxDQUFDOztBQVN2QixNQUFNLE9BQU8sMEJBQTBCOytHQUExQiwwQkFBMEI7bUdBQTFCLDBCQUEwQixvRkNadkMsNkJBQ0E7OzRGRFdhLDBCQUEwQjtrQkFQdEMsU0FBUzsrQkFDRSwwQkFBMEIsbUJBR25CLHVCQUF1QixDQUFDLE1BQU0sY0FDbkMsSUFBSSIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7XG4gIENoYW5nZURldGVjdGlvblN0cmF0ZWd5LFxuICBDb21wb25lbnQsXG59IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xuXG5AQ29tcG9uZW50KHtcbiAgc2VsZWN0b3I6ICduYXZbZi1mb290ZXItbmF2aWdhdGlvbl0nLFxuICB0ZW1wbGF0ZVVybDogJy4vZi1mb290ZXItbmF2aWdhdGlvbi5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWyAnLi9mLWZvb3Rlci1uYXZpZ2F0aW9uLmNvbXBvbmVudC5zY3NzJyBdLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBGRm9vdGVyTmF2aWdhdGlvbkNvbXBvbmVudCB7XG5cbn1cbiIsIjxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiJdfQ==

package/esm2022/lib/f-page/f-markdown-footer/f-footer-navigation/index.mjs

@@ -0,0 +1,3 @@
+export * from './f-footer-navigation-button';
+export * from './f-footer-navigation.component';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1uYXZpZ2F0aW9uL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsOEJBQThCLENBQUM7QUFFN0MsY0FBYyxpQ0FBaUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZi1mb290ZXItbmF2aWdhdGlvbi1idXR0b24nO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtZm9vdGVyLW5hdmlnYXRpb24uY29tcG9uZW50JztcblxuIl19