@foblex/m-render 2.5.1 → 2.5.3

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

@@ -0,0 +1,92 @@
+import { EMarkdownContainerType } from './e-markdown-container-type';
+import { getContent } from '../utils';
+import container from 'markdown-it-container';
+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-documentation/f-page/f-markdown/domain/markdown/parse-markdown/parse-example-group.ts"],"names":[],"mappings":"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","sourcesContent":["import { EMarkdownContainerType } from './e-markdown-container-type';\nimport { IMarkdownItToken } from './i-markdown-it-token';\nimport { getContent } from '../utils';\n\nimport container from 'markdown-it-container';\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-documentation/f-page/f-markdown/domain/markdown/parse-markdown/parse-preview-group.mjs

@@ -0,0 +1,50 @@
+import { EMarkdownContainerType } from './e-markdown-container-type';
+import { getContent } from '../utils';
+import container from 'markdown-it-container';
+export class ParsePreviewGroup {
+    navigation;
+    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-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZ2V0LWNvbnRlbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi9kb21haW4vbWFya2Rvd24vdXRpbHMvZ2V0LWNvbnRlbnQudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBRUEsTUFBTSxVQUFVLFVBQVUsQ0FBQyxNQUEwQixFQUFFLEtBQWEsRUFBRSxjQUFzQztJQUMxRyxJQUFJLE1BQTBCLENBQUM7SUFFL0IsS0FBSyxJQUFJLENBQUMsR0FBRyxLQUFLLEdBQUcsQ0FBQyxFQUFFLENBQUMsR0FBRyxNQUFNLENBQUMsTUFBTSxFQUFFLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDL0MsSUFBSSxNQUFNLENBQUUsQ0FBQyxDQUFFLENBQUMsSUFBSSxLQUFLLGFBQWMsY0FBZSxRQUFRLEVBQUUsQ0FBQztZQUMvRCxNQUFNO1FBQ1IsQ0FBQztRQUNELElBQUksYUFBYSxDQUFDLE1BQU0sQ0FBRSxDQUFDLENBQUUsQ0FBQyxFQUFFLENBQUM7WUFDL0IsTUFBTSxHQUFHLE1BQU0sQ0FBRSxDQUFDLENBQUUsQ0FBQyxPQUFPLENBQUM7WUFDN0IsTUFBTTtRQUNSLENBQUM7SUFDSCxDQUFDO0lBQ0QsT0FBTyxNQUFNLENBQUM7QUFDaEIsQ0FBQztBQUVELFNBQVMsYUFBYSxDQUFDLEtBQXVCO0lBQzVDLE9BQU8sS0FBSyxDQUFDLElBQUksS0FBSyxRQUFRLElBQUksQ0FBQyxLQUFLLENBQUMsR0FBRyxDQUFDO0FBQy9DLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFTWFya2Rvd25Db250YWluZXJUeXBlLCBJTWFya2Rvd25JdFRva2VuIH0gZnJvbSAnLi4vcGFyc2UtbWFya2Rvd24nO1xuXG5leHBvcnQgZnVuY3Rpb24gZ2V0Q29udGVudCh0b2tlbnM6IElNYXJrZG93bkl0VG9rZW5bXSwgaW5kZXg6IG51bWJlciwgZUNvbnRhaW5lclR5cGU6IEVNYXJrZG93bkNvbnRhaW5lclR5cGUpOiBzdHJpbmcgfCB1bmRlZmluZWQge1xuICBsZXQgcmVzdWx0OiBzdHJpbmcgfCB1bmRlZmluZWQ7XG5cbiAgZm9yIChsZXQgaSA9IGluZGV4ICsgMTsgaSA8IHRva2Vucy5sZW5ndGg7IGkrKykge1xuICAgIGlmICh0b2tlbnNbIGkgXS50eXBlID09PSBgY29udGFpbmVyXyR7IGVDb250YWluZXJUeXBlIH1fY2xvc2VgKSB7XG4gICAgICBicmVhaztcbiAgICB9XG4gICAgaWYgKGlzSW5saW5lVG9rZW4odG9rZW5zWyBpIF0pKSB7XG4gICAgICByZXN1bHQgPSB0b2tlbnNbIGkgXS5jb250ZW50O1xuICAgICAgYnJlYWs7XG4gICAgfVxuICB9XG4gIHJldHVybiByZXN1bHQ7XG59XG5cbmZ1bmN0aW9uIGlzSW5saW5lVG9rZW4odG9rZW46IElNYXJrZG93bkl0VG9rZW4pOiBib29sZWFuIHtcbiAgcmV0dXJuIHRva2VuLnR5cGUgPT09ICdpbmxpbmUnICYmICF0b2tlbi50YWc7XG59XG4iXX0=

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

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

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

@@ -0,0 +1,84 @@
+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 { HandleNavigationLinksHandler, HandleNavigationLinksRequest } from '../../../domain';
+import { FMarkdownFooterComponent } from '../f-markdown-footer';
+import { FDocumentationEnvironmentService } from '../../f-documentation-environment.service';
+import * as i0 from "@angular/core";
+export class FMarkdownRendererComponent {
+    injector;
+    changeDetectorRef;
+    subscriptions$ = new Subscription();
+    value;
+    hostElement = inject(ElementRef).nativeElement;
+    fScrollableService = inject(FScrollableService);
+    fContainersHandler = inject(HandleParsedContainersHandler);
+    fDynamicComponentsHandler = inject(HandleDynamicComponentsHandler);
+    isMarkdownChanged = false;
+    constructor(injector, changeDetectorRef) {
+        this.injector = injector;
+        this.changeDetectorRef = changeDetectorRef;
+    }
+    ngOnInit() {
+        this.subscriptions$.add(this.subscribeOnRouteChanges());
+    }
+    subscribeOnRouteChanges() {
+        return this.getRouterEvents().pipe(startWith(null), debounceTime(50), switchMap(() => this.injector.get(MarkdownService).parse(this.injector.get(FDocumentationEnvironmentService).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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FMarkdownRendererComponent, deps: [{ token: i0.Injector }, { token: i0.ChangeDetectorRef }], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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: "18.2.13", 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-documentation/f-page/f-markdown/f-markdown-renderer.component.ts","../../../../../../../projects/m-render/src/lib/f-documentation/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  HandleNavigationLinksHandler,\n  HandleNavigationLinksRequest\n} from '../../../domain';\nimport { FMarkdownFooterComponent } from '../f-markdown-footer';\nimport { FDocumentationEnvironmentService } from '../../f-documentation-environment.service';\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(FDocumentationEnvironmentService).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-documentation/f-page/f-markdown/index.mjs

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

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

@@ -0,0 +1,37 @@
+import { GetPreviousNextPageNavigationResponse } from './get-previous-next-page-navigation.response';
+export class GetPreviousNextPageNavigationHandler {
+    fEnvironmentService;
+    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-documentation/f-page/f-markdown-footer/domain/features/get-previous-next-page-navigation/get-previous-next-page-navigation.request.mjs

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

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

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

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZG9tYWluL2ZlYXR1cmVzL2dldC1wcmV2aW91cy1uZXh0LXBhZ2UtbmF2aWdhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZDQUE2QyxDQUFDO0FBRTVELGNBQWMsNkNBQTZDLENBQUM7QUFFNUQsY0FBYyw4Q0FBOEMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZ2V0LXByZXZpb3VzLW5leHQtcGFnZS1uYXZpZ2F0aW9uLmhhbmRsZXInO1xuXG5leHBvcnQgKiBmcm9tICcuL2dldC1wcmV2aW91cy1uZXh0LXBhZ2UtbmF2aWdhdGlvbi5yZXF1ZXN0JztcblxuZXhwb3J0ICogZnJvbSAnLi9nZXQtcHJldmlvdXMtbmV4dC1wYWdlLW5hdmlnYXRpb24ucmVzcG9uc2UnO1xuIl19

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZG9tYWluL2ZlYXR1cmVzL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMscUNBQXFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2dldC1wcmV2aW91cy1uZXh0LXBhZ2UtbmF2aWdhdGlvbic7XG4iXX0=

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

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

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZG9tYWluL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLGNBQWMsWUFBWSxDQUFDO0FBRTNCLGNBQWMsZUFBZSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mZWF0dXJlcyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vaS1wYWdlLWxpbmsnO1xuIl19

package/esm2022/lib/f-documentation/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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FFooterEditInformationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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: "18.2.13", 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1kb2N1bWVudGF0aW9uL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24uY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixTQUFTLEdBQ1YsTUFBTSxlQUFlLENBQUM7O0FBU3ZCLE1BQU0sT0FBTywrQkFBK0I7d0dBQS9CLCtCQUErQjs0RkFBL0IsK0JBQStCLHFGQ1o1Qyw2QkFDQTs7NEZEV2EsK0JBQStCO2tCQVAzQyxTQUFTOytCQUNFLDJCQUEyQixtQkFHcEIsdUJBQXVCLENBQUMsTUFBTSxjQUNuQyxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENvbXBvbmVudCxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24nLFxuICB0ZW1wbGF0ZVVybDogJy4vZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWyAnLi9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uLmNvbXBvbmVudC5zY3NzJyBdLFxuICBjaGFuZ2VEZXRlY3Rpb246IENoYW5nZURldGVjdGlvblN0cmF0ZWd5Lk9uUHVzaCxcbiAgc3RhbmRhbG9uZTogdHJ1ZVxufSlcbmV4cG9ydCBjbGFzcyBGRm9vdGVyRWRpdEluZm9ybWF0aW9uQ29tcG9uZW50IHtcblxufVxuIiwiPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuIl19

package/esm2022/lib/f-documentation/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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FFooterEditLinkComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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: "18.2.13", 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItZWRpdC1saW5rLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1kb2N1bWVudGF0aW9uL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWVkaXQtbGluay9mLWZvb3Rlci1lZGl0LWxpbmsuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbS1yZW5kZXIvc3JjL2xpYi9mLWRvY3VtZW50YXRpb24vZi1wYWdlL2YtbWFya2Rvd24tZm9vdGVyL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24vZi1mb290ZXItZWRpdC1saW5rL2YtZm9vdGVyLWVkaXQtbGluay5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLFNBQVMsR0FDVixNQUFNLGVBQWUsQ0FBQzs7QUFTdkIsTUFBTSxPQUFPLHdCQUF3Qjt3R0FBeEIsd0JBQXdCOzRGQUF4Qix3QkFBd0IsaUZDWnJDLGlGQUVBOzs0RkRVYSx3QkFBd0I7a0JBUHBDLFNBQVM7K0JBQ0UsdUJBQXVCLG1CQUdoQix1QkFBdUIsQ0FBQyxNQUFNLGNBQ25DLElBQUkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSxcbiAgQ29tcG9uZW50LFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnYVtmLWZvb3Rlci1lZGl0LWxpbmtdJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2YtZm9vdGVyLWVkaXQtbGluay5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWyAnLi9mLWZvb3Rlci1lZGl0LWxpbmsuY29tcG9uZW50LnNjc3MnIF0sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIEZGb290ZXJFZGl0TGlua0NvbXBvbmVudCB7XG5cbn1cbiIsIjxzcGFuIGNsYXNzPVwiZWRpdC1saW5rLWljb24gZi1pY29uIGVkaXRcIj48L3NwYW4+XG48bmctY29udGVudD48L25nLWNvbnRlbnQ+XG4iXX0=

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi9mLWZvb3Rlci1lZGl0LWxpbmsvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxnQ0FBZ0MsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZi1mb290ZXItZWRpdC1saW5rLmNvbXBvbmVudCc7XG5cbiJdfQ==

package/esm2022/lib/f-documentation/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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FFooterLastUpdatedComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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: "18.2.13", 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItbGFzdC11cGRhdGVkLmNvbXBvbmVudC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1kb2N1bWVudGF0aW9uL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uL2YtZm9vdGVyLWxhc3QtdXBkYXRlZC9mLWZvb3Rlci1sYXN0LXVwZGF0ZWQuY29tcG9uZW50LnRzIiwiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbS1yZW5kZXIvc3JjL2xpYi9mLWRvY3VtZW50YXRpb24vZi1wYWdlL2YtbWFya2Rvd24tZm9vdGVyL2YtZm9vdGVyLWVkaXQtaW5mb3JtYXRpb24vZi1mb290ZXItbGFzdC11cGRhdGVkL2YtZm9vdGVyLWxhc3QtdXBkYXRlZC5jb21wb25lbnQuaHRtbCJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQ0wsdUJBQXVCLEVBQ3ZCLFNBQVMsR0FDVixNQUFNLGVBQWUsQ0FBQzs7QUFTdkIsTUFBTSxPQUFPLDJCQUEyQjt3R0FBM0IsMkJBQTJCOzRGQUEzQiwyQkFBMkIsaUZDWnhDLDZCQUNBOzs0RkRXYSwyQkFBMkI7a0JBUHZDLFNBQVM7K0JBQ0UsdUJBQXVCLG1CQUdoQix1QkFBdUIsQ0FBQyxNQUFNLGNBQ25DLElBQUkiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge1xuICBDaGFuZ2VEZXRlY3Rpb25TdHJhdGVneSxcbiAgQ29tcG9uZW50LFxufSBmcm9tICdAYW5ndWxhci9jb3JlJztcblxuQENvbXBvbmVudCh7XG4gIHNlbGVjdG9yOiAnZi1mb290ZXItbGFzdC11cGRhdGVkJyxcbiAgdGVtcGxhdGVVcmw6ICcuL2YtZm9vdGVyLWxhc3QtdXBkYXRlZC5jb21wb25lbnQuaHRtbCcsXG4gIHN0eWxlVXJsczogWyAnLi9mLWZvb3Rlci1sYXN0LXVwZGF0ZWQuY29tcG9uZW50LnNjc3MnIF0sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIEZGb290ZXJMYXN0VXBkYXRlZENvbXBvbmVudCB7XG5cbn1cbiIsIjxuZy1jb250ZW50PjwvbmctY29udGVudD5cbiJdfQ==

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi9mLWZvb3Rlci1sYXN0LXVwZGF0ZWQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxtQ0FBbUMsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vZi1mb290ZXItbGFzdC11cGRhdGVkLmNvbXBvbmVudCc7XG5cbiJdfQ==

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItZWRpdC1pbmZvcm1hdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVDQUF1QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mLWZvb3Rlci1lZGl0LWluZm9ybWF0aW9uLmNvbXBvbmVudCc7XG5cbiJdfQ==

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

@@ -0,0 +1,19 @@
+import { ChangeDetectionStrategy, Component, Input, } from '@angular/core';
+import * as i0 from "@angular/core";
+export class FFooterNavigationButtonComponent {
+    description;
+    link;
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FFooterNavigationButtonComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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: "18.2.13", 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,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

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItbmF2aWdhdGlvbi9mLWZvb3Rlci1uYXZpZ2F0aW9uLWJ1dHRvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHdDQUF3QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9mLWZvb3Rlci1uYXZpZ2F0aW9uLWJ1dHRvbi5jb21wb25lbnQnO1xuXG4iXX0=

package/esm2022/lib/f-documentation/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 ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "18.2.13", ngImport: i0, type: FFooterNavigationComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "18.2.13", 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: "18.2.13", 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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1mb290ZXItbmF2aWdhdGlvbi5jb21wb25lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItbmF2aWdhdGlvbi9mLWZvb3Rlci1uYXZpZ2F0aW9uLmNvbXBvbmVudC50cyIsIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1kb2N1bWVudGF0aW9uL2YtcGFnZS9mLW1hcmtkb3duLWZvb3Rlci9mLWZvb3Rlci1uYXZpZ2F0aW9uL2YtZm9vdGVyLW5hdmlnYXRpb24uY29tcG9uZW50Lmh0bWwiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxFQUNMLHVCQUF1QixFQUN2QixTQUFTLEdBQ1YsTUFBTSxlQUFlLENBQUM7O0FBU3ZCLE1BQU0sT0FBTywwQkFBMEI7d0dBQTFCLDBCQUEwQjs0RkFBMUIsMEJBQTBCLG9GQ1p2Qyw2QkFDQTs7NEZEV2EsMEJBQTBCO2tCQVB0QyxTQUFTOytCQUNFLDBCQUEwQixtQkFHbkIsdUJBQXVCLENBQUMsTUFBTSxjQUNuQyxJQUFJIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHtcbiAgQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3ksXG4gIENvbXBvbmVudCxcbn0gZnJvbSAnQGFuZ3VsYXIvY29yZSc7XG5cbkBDb21wb25lbnQoe1xuICBzZWxlY3RvcjogJ25hdltmLWZvb3Rlci1uYXZpZ2F0aW9uXScsXG4gIHRlbXBsYXRlVXJsOiAnLi9mLWZvb3Rlci1uYXZpZ2F0aW9uLmNvbXBvbmVudC5odG1sJyxcbiAgc3R5bGVVcmxzOiBbICcuL2YtZm9vdGVyLW5hdmlnYXRpb24uY29tcG9uZW50LnNjc3MnIF0sXG4gIGNoYW5nZURldGVjdGlvbjogQ2hhbmdlRGV0ZWN0aW9uU3RyYXRlZ3kuT25QdXNoLFxuICBzdGFuZGFsb25lOiB0cnVlXG59KVxuZXhwb3J0IGNsYXNzIEZGb290ZXJOYXZpZ2F0aW9uQ29tcG9uZW50IHtcblxufVxuIiwiPG5nLWNvbnRlbnQ+PC9uZy1jb250ZW50PlxuIl19

package/esm2022/lib/f-documentation/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,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtZG9jdW1lbnRhdGlvbi9mLXBhZ2UvZi1tYXJrZG93bi1mb290ZXIvZi1mb290ZXItbmF2aWdhdGlvbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDhCQUE4QixDQUFDO0FBRTdDLGNBQWMsaUNBQWlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2YtZm9vdGVyLW5hdmlnYXRpb24tYnV0dG9uJztcblxuZXhwb3J0ICogZnJvbSAnLi9mLWZvb3Rlci1uYXZpZ2F0aW9uLmNvbXBvbmVudCc7XG5cbiJdfQ==