@foblex/m-render 2.5.1

package/esm2022/lib/f-page/f-markdown/domain/handle-parsed-containers/pseudo-components/f-code-group-body.handler.mjs

@@ -0,0 +1,45 @@
+import { FCodeViewHandler } from './f-code-view-handler';
+import { FExampleViewHandler } from './f-example-view-handler';
+import { FAsyncCodeViewHandler } from './f-async-code-view-handler';
+export class FCodeGroupBodyHandler {
+    constructor(element, injector) {
+        this.element = element;
+        this.injector = injector;
+        this.fContainerHandlers = this.getCodeViews();
+        this.initialize();
+    }
+    initialize() {
+        this.toggle(0);
+    }
+    getCodeViews() {
+        return this.getGroupBodyChildren().map((x) => {
+            if (this.isCodeView(x)) {
+                return new FCodeViewHandler(x, this.injector);
+            }
+            else if (this.isAsyncCodeView(x)) {
+                return new FAsyncCodeViewHandler(x, this.injector);
+            }
+            else {
+                return new FExampleViewHandler(x);
+            }
+        });
+    }
+    getGroupBodyChildren() {
+        return Array.from(this.element.querySelector('.f-code-group-body').children);
+    }
+    isCodeView(element) {
+        return element.classList.contains('f-code-view');
+    }
+    isAsyncCodeView(element) {
+        return element.classList.contains('f-async-code-view');
+    }
+    toggle(index) {
+        this.fContainerHandlers.forEach((fContainer, tabIndex) => {
+            fContainer.setDisplay(tabIndex === index ? 'block' : 'none');
+        });
+    }
+    dispose() {
+        this.fContainerHandlers.forEach((x) => x.dispose?.());
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/f-page/f-markdown/domain/handle-parsed-containers/pseudo-components/f-code-view-handler.mjs

@@ -0,0 +1,60 @@
+import { fromEvent, Subscription, switchMap } from 'rxjs';
+import { copyToClipboard } from './clipboard';
+import { HighlightService } from '../../highlight';
+import { take } from 'rxjs/operators';
+import { FPopoverService } from '../../../../../domain';
+import { DOCUMENT } from '@angular/common';
+export class FCodeViewHandler {
+    constructor(element, injector) {
+        this.element = element;
+        this.injector = injector;
+        this.subscriptions$ = new Subscription();
+        this.fDocument = this.injector.get(DOCUMENT);
+        this.initialize();
+    }
+    initialize() {
+        if (this.isServer())
+            return;
+        this.createCopyButton();
+        this.createLanguageBadge();
+        this.injector.get(HighlightService).highlight(this.element).pipe(take(1)).subscribe(() => {
+            this.subscriptions$.add(this.subscribeOnCopyButtonClick());
+        });
+    }
+    isServer() {
+        return typeof window === 'undefined';
+    }
+    createCopyButton() {
+        const button = this.fDocument.createElement('button');
+        button.classList.add('f-copy-button');
+        this.element.appendChild(button);
+        return button;
+    }
+    createLanguageBadge() {
+        const badge = this.fDocument.createElement('span');
+        badge.classList.add('f-code-language');
+        badge.textContent = this.getLanguage();
+        this.element.appendChild(badge);
+    }
+    getLanguage() {
+        return this.getCodeBlock().classList[0].replace('language-', '');
+    }
+    getCopyButton() {
+        return this.element.querySelector('.f-copy-button');
+    }
+    getCodeBlock() {
+        return this.element.querySelector('code');
+    }
+    setDisplay(value) {
+        this.element.style.display = value;
+    }
+    subscribeOnCopyButtonClick() {
+        return fromEvent(this.getCopyButton(), 'click').pipe(switchMap(() => copyToClipboard(this.getCodeBlock().textContent))).subscribe(() => {
+            this.injector.get(FPopoverService).show('Copied!');
+        });
+    }
+    dispose() {
+        this.subscriptions$.unsubscribe();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/f-page/f-markdown/domain/handle-parsed-containers/pseudo-components/f-example-view-handler.mjs

@@ -0,0 +1,9 @@
+export class FExampleViewHandler {
+    constructor(element) {
+        this.element = element;
+    }
+    setDisplay(value) {
+        this.element.style.display = value;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZi1leGFtcGxlLXZpZXctaGFuZGxlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1wYWdlL2YtbWFya2Rvd24vZG9tYWluL2hhbmRsZS1wYXJzZWQtY29udGFpbmVycy9wc2V1ZG8tY29tcG9uZW50cy9mLWV4YW1wbGUtdmlldy1oYW5kbGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBLE1BQU0sT0FBTyxtQkFBbUI7SUFFOUIsWUFDUyxPQUFvQjtRQUFwQixZQUFPLEdBQVAsT0FBTyxDQUFhO0lBRTdCLENBQUM7SUFFTSxVQUFVLENBQUMsS0FBYTtRQUM3QixJQUFJLENBQUMsT0FBTyxDQUFDLEtBQUssQ0FBQyxPQUFPLEdBQUcsS0FBSyxDQUFDO0lBQ3JDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IElDb2RlR3JvdXBWaWV3IH0gZnJvbSAnLi9mLWNvZGUtZ3JvdXAnO1xuXG5leHBvcnQgY2xhc3MgRkV4YW1wbGVWaWV3SGFuZGxlciBpbXBsZW1lbnRzIElDb2RlR3JvdXBWaWV3IHtcblxuICBjb25zdHJ1Y3RvcihcbiAgICBwdWJsaWMgZWxlbWVudDogSFRNTEVsZW1lbnQsXG4gICkge1xuICB9XG5cbiAgcHVibGljIHNldERpc3BsYXkodmFsdWU6IHN0cmluZyk6IHZvaWQge1xuICAgIHRoaXMuZWxlbWVudC5zdHlsZS5kaXNwbGF5ID0gdmFsdWU7XG4gIH1cbn1cbiJdfQ==

package/esm2022/lib/f-page/f-markdown/domain/handle-parsed-containers/pseudo-components/index.mjs

@@ -0,0 +1,7 @@
+export * from './clipboard';
+export * from './f-code-group';
+export * from './f-async-code-view-handler';
+export * from './f-code-group-body.handler';
+export * from './f-code-view-handler';
+export * from './f-example-view-handler';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2RvbWFpbi9oYW5kbGUtcGFyc2VkLWNvbnRhaW5lcnMvcHNldWRvLWNvbXBvbmVudHMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxhQUFhLENBQUM7QUFFNUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUUvQixjQUFjLDZCQUE2QixDQUFDO0FBRTVDLGNBQWMsNkJBQTZCLENBQUM7QUFFNUMsY0FBYyx1QkFBdUIsQ0FBQztBQUV0QyxjQUFjLDBCQUEwQixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jbGlwYm9hcmQnO1xuXG5leHBvcnQgKiBmcm9tICcuL2YtY29kZS1ncm91cCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1hc3luYy1jb2RlLXZpZXctaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1jb2RlLWdyb3VwLWJvZHkuaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1jb2RlLXZpZXctaGFuZGxlcic7XG5cbmV4cG9ydCAqIGZyb20gJy4vZi1leGFtcGxlLXZpZXctaGFuZGxlcic7XG4iXX0=

package/esm2022/lib/f-page/f-markdown/domain/highlight/change-code-focused-syntax.pre-processor.mjs

@@ -0,0 +1,23 @@
+import { of } from 'rxjs';
+//To prevent replacing the focus syntax (Prism) in the code blocks, we need to change from the default syntax to a custom one.
+export class ChangeCodeFocusedSyntaxPreProcessor {
+    handle(element) {
+        this.getCodeBlocks(element).forEach((block) => {
+            block.innerHTML = this.replaceFocus(block.innerHTML);
+        });
+        return of(element);
+    }
+    getCodeBlocks(element) {
+        return Array.from(element.querySelectorAll('pre code'));
+    }
+    replaceFocus(text) {
+        return text.replace(RULE.regex, RULE.replacer);
+    }
+}
+const RULE = {
+    regex: /\|:\|(.*?)\|:\|/g,
+    replacer: (match, p1) => {
+        return `|foc-|${p1}|-foc|`;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/f-page/f-markdown/domain/highlight/highlight.service.mjs

@@ -0,0 +1,54 @@
+import { Injectable } from '@angular/core';
+import { Observable, of, switchMap } from 'rxjs';
+import { ChangeCodeFocusedSyntaxPreProcessor } from './change-code-focused-syntax.pre-processor';
+import { SeparateCodeByLinesPostProcessor } from './separate-code-by-lines.post-processor';
+import { ModifyPunctuationHighlightPostProcessor } from './modify-punctuation-highlight.post-processor';
+import { MarkCodeFocusedBlocksPostProcessor } from './mark-code-focused-blocks.post-processor';
+import * as i0 from "@angular/core";
+import * as i1 from "@foblex/platform";
+export class HighlightService {
+    constructor(fBrowser) {
+        this.fBrowser = fBrowser;
+    }
+    highlight(element) {
+        return this.fBrowser.isBrowser() ? this.markNoneLanguage(element).pipe(switchMap((x) => new ChangeCodeFocusedSyntaxPreProcessor().handle(x)), switchMap((x) => this.highlightCodeWithPrism(x)), switchMap((x) => new ModifyPunctuationHighlightPostProcessor().handle(x)), switchMap((x) => new SeparateCodeByLinesPostProcessor().handle(x)), switchMap((x) => new MarkCodeFocusedBlocksPostProcessor(this.fBrowser).handle(x))) : of(element);
+    }
+    highlightCodeWithPrism(element) {
+        return new Observable((observer) => {
+            setTimeout(() => {
+                this.loadPrism().then((x) => {
+                    this.highlightAllUnder(x, observer, element);
+                });
+            });
+        });
+    }
+    highlightAllUnder(prism, observer, element) {
+        try {
+            prism?.highlightAllUnder(element);
+        }
+        catch (e) {
+        }
+        observer.next(element);
+        observer.complete();
+    }
+    async loadPrism() {
+        if (!this.Prism) {
+            this.Prism = await import('prismjs');
+            await Promise.all([
+                // @ts-ignore
+                import('prismjs/components/prism-bash'), import('prismjs/components/prism-css'), import('prismjs/components/prism-typescript')
+            ]);
+        }
+        return this.Prism;
+    }
+    markNoneLanguage(element) {
+        element.querySelectorAll('pre code:not([class*="language-"])').forEach((x) => x.classList.add('language-none'));
+        return of(element);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HighlightService, deps: [{ token: i1.BrowserService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HighlightService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: HighlightService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.BrowserService }] });
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,6 @@
+export * from './change-code-focused-syntax.pre-processor';
+export * from './highlight.service';
+export * from './mark-code-focused-blocks.post-processor';
+export * from './modify-punctuation-highlight.post-processor';
+export * from './separate-code-by-lines.post-processor';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2RvbWFpbi9oaWdobGlnaHQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyw0Q0FBNEMsQ0FBQztBQUUzRCxjQUFjLHFCQUFxQixDQUFDO0FBRXBDLGNBQWMsMkNBQTJDLENBQUM7QUFFMUQsY0FBYywrQ0FBK0MsQ0FBQztBQUU5RCxjQUFjLHlDQUF5QyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jaGFuZ2UtY29kZS1mb2N1c2VkLXN5bnRheC5wcmUtcHJvY2Vzc29yJztcblxuZXhwb3J0ICogZnJvbSAnLi9oaWdobGlnaHQuc2VydmljZSc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbWFyay1jb2RlLWZvY3VzZWQtYmxvY2tzLnBvc3QtcHJvY2Vzc29yJztcblxuZXhwb3J0ICogZnJvbSAnLi9tb2RpZnktcHVuY3R1YXRpb24taGlnaGxpZ2h0LnBvc3QtcHJvY2Vzc29yJztcblxuZXhwb3J0ICogZnJvbSAnLi9zZXBhcmF0ZS1jb2RlLWJ5LWxpbmVzLnBvc3QtcHJvY2Vzc29yJztcbiJdfQ==

package/esm2022/lib/f-page/f-markdown/domain/highlight/mark-code-focused-blocks.post-processor.mjs

@@ -0,0 +1,52 @@
+import { of } from 'rxjs';
+export class MarkCodeFocusedBlocksPostProcessor {
+    constructor(fBrowser) {
+        this.fBrowser = fBrowser;
+    }
+    handle(element) {
+        this.getCodeBlocks(element).forEach((block) => {
+            block.innerHTML = this.replaceFocus(block.innerHTML);
+            if (block.querySelector('.focused')) {
+                this.applyOpacity(block.parentElement);
+            }
+        });
+        return of(element);
+    }
+    getCodeBlocks(element) {
+        return Array.from(element.querySelectorAll('pre code'));
+    }
+    replaceFocus(text) {
+        return text.replace(RULE.regex, RULE.replacer);
+    }
+    applyOpacity(element) {
+        if (!element.classList.contains('focused')) {
+            element.style.color = this.createRgbaString(this.getElementColor(element), 0.5);
+            element.childNodes.forEach((child) => {
+                if (child.nodeType === Node.ELEMENT_NODE) {
+                    this.applyOpacity(child);
+                }
+            });
+        }
+        else {
+            element.style.color = this.createRgbaString(this.getElementColor(element), 1, true);
+        }
+    }
+    getElementColor(element) {
+        return this.fBrowser.window.getComputedStyle(element).color;
+    }
+    createRgbaString(color, opacity, isRgb = false) {
+        const [r, g, b, a] = this.getRgbValues(color);
+        const alpha = Number(a) || 1;
+        return isRgb ? `rgb(${r}, ${g}, ${b})` : `rgba(${r}, ${g}, ${b}, ${opacity * alpha})`;
+    }
+    getRgbValues(color) {
+        return color.match(/\d+/g);
+    }
+}
+const RULE = {
+    regex: /\|foc-\|(.*?)\|-foc\|/g,
+    replacer: (match, p1) => {
+        return `<focus class="focused">${p1}</focus>`;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/f-page/f-markdown/domain/highlight/modify-punctuation-highlight.post-processor.mjs

@@ -0,0 +1,22 @@
+import { of } from 'rxjs';
+export class ModifyPunctuationHighlightPostProcessor {
+    handle(element) {
+        element.querySelectorAll('span.token.attr-name').forEach((node) => {
+            const text = node.textContent;
+            if (text && text.startsWith('[') && text.endsWith(']')) {
+                node.innerHTML = this.replacePunctuation(text);
+            }
+        });
+        return of(element);
+    }
+    replacePunctuation(text) {
+        return text.replace(RULE.regex, RULE.replacer);
+    }
+}
+const RULE = {
+    regex: /(\[|\])/g,
+    replacer: (match) => {
+        return `<span class="token punctuation">${match}</span>`;
+    }
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kaWZ5LXB1bmN0dWF0aW9uLWhpZ2hsaWdodC5wb3N0LXByb2Nlc3Nvci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1wYWdlL2YtbWFya2Rvd24vZG9tYWluL2hpZ2hsaWdodC9tb2RpZnktcHVuY3R1YXRpb24taGlnaGxpZ2h0LnBvc3QtcHJvY2Vzc29yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBYyxFQUFFLEVBQUUsTUFBTSxNQUFNLENBQUM7QUFHdEMsTUFBTSxPQUFPLHVDQUF1QztJQUUzQyxNQUFNLENBQUMsT0FBb0I7UUFDaEMsT0FBTyxDQUFDLGdCQUFnQixDQUFDLHNCQUFzQixDQUFDLENBQUMsT0FBTyxDQUFDLENBQUMsSUFBSSxFQUFFLEVBQUU7WUFDaEUsTUFBTSxJQUFJLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQztZQUM5QixJQUFJLElBQUksSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLEdBQUcsQ0FBQyxJQUFJLElBQUksQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLEVBQUUsQ0FBQztnQkFDdkQsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsa0JBQWtCLENBQUMsSUFBSSxDQUFDLENBQUM7WUFDakQsQ0FBQztRQUNILENBQUMsQ0FBQyxDQUFDO1FBQ0gsT0FBTyxFQUFFLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDckIsQ0FBQztJQUVPLGtCQUFrQixDQUFDLElBQVk7UUFDckMsT0FBTyxJQUFJLENBQUMsT0FBTyxDQUFDLElBQUksQ0FBQyxLQUFLLEVBQUUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxDQUFDO0lBQ2pELENBQUM7Q0FDRjtBQUVELE1BQU0sSUFBSSxHQUFHO0lBQ1gsS0FBSyxFQUFFLFVBQVU7SUFDakIsUUFBUSxFQUFFLENBQUMsS0FBVSxFQUFFLEVBQUU7UUFDdkIsT0FBTyxtQ0FBb0MsS0FBTSxTQUFTLENBQUM7SUFDN0QsQ0FBQztDQUNGLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBPYnNlcnZhYmxlLCBvZiB9IGZyb20gJ3J4anMnO1xuaW1wb3J0IHsgSUhhbmRsZXIgfSBmcm9tICdAZm9ibGV4L21lZGlhdG9yJztcblxuZXhwb3J0IGNsYXNzIE1vZGlmeVB1bmN0dWF0aW9uSGlnaGxpZ2h0UG9zdFByb2Nlc3NvciBpbXBsZW1lbnRzIElIYW5kbGVyPEhUTUxFbGVtZW50LCBPYnNlcnZhYmxlPEhUTUxFbGVtZW50Pj4ge1xuXG4gIHB1YmxpYyBoYW5kbGUoZWxlbWVudDogSFRNTEVsZW1lbnQpOiBPYnNlcnZhYmxlPEhUTUxFbGVtZW50PiB7XG4gICAgZWxlbWVudC5xdWVyeVNlbGVjdG9yQWxsKCdzcGFuLnRva2VuLmF0dHItbmFtZScpLmZvckVhY2goKG5vZGUpID0+IHtcbiAgICAgIGNvbnN0IHRleHQgPSBub2RlLnRleHRDb250ZW50O1xuICAgICAgaWYgKHRleHQgJiYgdGV4dC5zdGFydHNXaXRoKCdbJykgJiYgdGV4dC5lbmRzV2l0aCgnXScpKSB7XG4gICAgICAgIG5vZGUuaW5uZXJIVE1MID0gdGhpcy5yZXBsYWNlUHVuY3R1YXRpb24odGV4dCk7XG4gICAgICB9XG4gICAgfSk7XG4gICAgcmV0dXJuIG9mKGVsZW1lbnQpO1xuICB9XG5cbiAgcHJpdmF0ZSByZXBsYWNlUHVuY3R1YXRpb24odGV4dDogc3RyaW5nKTogc3RyaW5nIHtcbiAgICByZXR1cm4gdGV4dC5yZXBsYWNlKFJVTEUucmVnZXgsIFJVTEUucmVwbGFjZXIpO1xuICB9XG59XG5cbmNvbnN0IFJVTEUgPSB7XG4gIHJlZ2V4OiAvKFxcW3xcXF0pL2csXG4gIHJlcGxhY2VyOiAobWF0Y2g6IGFueSkgPT4ge1xuICAgIHJldHVybiBgPHNwYW4gY2xhc3M9XCJ0b2tlbiBwdW5jdHVhdGlvblwiPiR7IG1hdGNoIH08L3NwYW4+YDtcbiAgfVxufTtcbiJdfQ==

package/esm2022/lib/f-page/f-markdown/domain/highlight/separate-code-by-lines.post-processor.mjs

@@ -0,0 +1,28 @@
+import { of } from 'rxjs';
+export class SeparateCodeByLinesPostProcessor {
+    handle(element) {
+        element.querySelectorAll("pre code").forEach((code) => {
+            code.innerHTML = this.getCodeDividedByLines(code);
+        });
+        return of(element);
+    }
+    getCodeDividedByLines(code) {
+        let result = '';
+        this.getLines(code).forEach(line => {
+            if (!this.isLineEmpty(line)) {
+                result += this.getLine(line);
+            }
+        });
+        return result;
+    }
+    getLines(code) {
+        return code.innerHTML.split('\n');
+    }
+    isLineEmpty(line) {
+        return line.trim() === '';
+    }
+    getLine(content) {
+        return `<line class="line">${content}</line>\n`;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,5 @@
+export * from './handle-dynamic-components';
+export * from './handle-parsed-containers';
+export * from './highlight';
+export * from './markdown';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2RvbWFpbi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLGNBQWMsNEJBQTRCLENBQUM7QUFFM0MsY0FBYyxhQUFhLENBQUM7QUFFNUIsY0FBYyxZQUFZLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2hhbmRsZS1keW5hbWljLWNvbXBvbmVudHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL2hhbmRsZS1wYXJzZWQtY29udGFpbmVycyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vaGlnaGxpZ2h0JztcblxuZXhwb3J0ICogZnJvbSAnLi9tYXJrZG93bic7XG5cbiJdfQ==

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

@@ -0,0 +1,4 @@
+export * from './parse-markdown';
+export * from './utils';
+export * from './markdown.service';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2RvbWFpbi9tYXJrZG93bi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGtCQUFrQixDQUFDO0FBRWpDLGNBQWMsU0FBUyxDQUFDO0FBRXhCLGNBQWMsb0JBQW9CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL3BhcnNlLW1hcmtkb3duJztcblxuZXhwb3J0ICogZnJvbSAnLi91dGlscyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vbWFya2Rvd24uc2VydmljZSc7XG4iXX0=

package/esm2022/lib/f-page/f-markdown/domain/markdown/markdown.service.mjs

@@ -0,0 +1,65 @@
+import { Injectable } from '@angular/core';
+import { of, switchMap } from 'rxjs';
+import MarkdownIt from 'markdown-it';
+import { EMarkdownContainerType, ParseAlerts, ParseCodeGroup, ParseCodeView, ParseExampleGroup, ParsePreviewGroup } from './parse-markdown';
+import { catchError, take } from 'rxjs/operators';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "@angular/platform-browser";
+import * as i3 from "../../../../domain";
+import * as i4 from "@angular/router";
+export class MarkdownService {
+    constructor(httpClient, domSanitizer, fEnvironment, router) {
+        this.httpClient = httpClient;
+        this.domSanitizer = domSanitizer;
+        this.fEnvironment = fEnvironment;
+        this.router = router;
+        this.markdown = new MarkdownIt({ html: true, linkify: true });
+        this.markdown
+            .use((x) => new ParseCodeView().render(x))
+            .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_TIP, this.markdown))
+            .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_INFO, this.markdown))
+            .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_WARNING, this.markdown))
+            .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_DANGER, this.markdown))
+            .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_DANGER, this.markdown))
+            .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_SUCCESS, this.markdown))
+            .use(...new ParseCodeGroup().render())
+            .use(...new ParsePreviewGroup(this.fEnvironment.getNavigation()).render())
+            .use(...new ParseExampleGroup().render());
+    }
+    parse(src) {
+        return this.httpClient.get(src, { responseType: 'text' }).pipe(take(1), catchError(() => of(''))).pipe(switchMap((text) => of(this.markdown.render(text))), switchMap((x) => of(this.cleanupEmptyParagraphs(x))), switchMap((x) => of(this.cleanupWasteParagraphFromExampleView(x))), switchMap((x) => of(this.cleanupWasteParagraphFromPreviewGroup(x))), switchMap((x) => of(this.normalizeLinks(x))), switchMap((x) => of(this.domSanitizer.bypassSecurityTrustHtml(x))));
+    }
+    normalizeLinks(html) {
+        const currentPath = this.router.url;
+        const prefix = currentPath.substring(0, currentPath.lastIndexOf('/'));
+        return html.replace(/<a\s+href="([^"]*)"/g, (match, href) => {
+            if (!this.isExternalLink(href)) {
+                let newHref = href.substring(0);
+                if (!href.startsWith('./')) {
+                    newHref = href.startsWith('/') ? `${prefix}${href}` : `${prefix}/${href}`;
+                }
+                return `<a href="${newHref}"`;
+            }
+            return match;
+        });
+    }
+    isExternalLink(href) {
+        return href.startsWith('www') || href.startsWith('http');
+    }
+    cleanupEmptyParagraphs(html) {
+        return html.replace(/<p>\s*<\/p>/g, '');
+    }
+    cleanupWasteParagraphFromExampleView(html) {
+        return html.replace(/<div class="f-code-group-body">\s*<p>[^<]*<\/p>/g, '<div class="f-code-group-body">');
+    }
+    cleanupWasteParagraphFromPreviewGroup(html) {
+        return html.replace(/<p>(\[[^\]]+\](\s*\[[^\]]+\])*)<\/p>/g, '');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MarkdownService, deps: [{ token: i1.HttpClient }, { token: i2.DomSanitizer }, { token: i3.FEnvironmentService }, { token: i4.Router }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MarkdownService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: MarkdownService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ type: i1.HttpClient }, { type: i2.DomSanitizer }, { type: i3.FEnvironmentService }, { type: i4.Router }] });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"markdown.service.js","sourceRoot":"","sources":["../../../../../../../../projects/m-render/src/lib/f-page/f-markdown/domain/markdown/markdown.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable } from '@angular/core';\nimport { Observable, of, switchMap } from 'rxjs';\nimport { HttpClient } from '@angular/common/http';\nimport MarkdownIt from 'markdown-it';\nimport {\n  EMarkdownContainerType,\n  ParseAlerts,\n  ParseCodeGroup,\n  ParseCodeView,\n  ParseExampleGroup, ParsePreviewGroup\n} from './parse-markdown';\nimport { DomSanitizer, SafeHtml } from '@angular/platform-browser';\nimport { catchError, take } from 'rxjs/operators';\nimport { Router } from '@angular/router';\nimport { FEnvironmentService } from '../../../../domain';\n\n@Injectable()\nexport class MarkdownService {\n\n  private markdown: MarkdownIt = new MarkdownIt({ html: true, linkify: true });\n\n  constructor(\n    private httpClient: HttpClient,\n    private domSanitizer: DomSanitizer,\n    private fEnvironment: FEnvironmentService,\n    private router: Router,\n  ) {\n    this.markdown\n      .use((x) => new ParseCodeView().render(x))\n      .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_TIP, this.markdown))\n      .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_INFO, this.markdown))\n      .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_WARNING, this.markdown))\n      .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_DANGER, this.markdown))\n      .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_DANGER, this.markdown))\n      .use(...new ParseAlerts().render(EMarkdownContainerType.ALERT_SUCCESS, this.markdown))\n      .use(...new ParseCodeGroup().render())\n      .use(...new ParsePreviewGroup(this.fEnvironment.getNavigation()).render())\n      .use(...new ParseExampleGroup().render());\n  }\n\n  public parse(src: string): Observable<SafeHtml> {\n    return this.httpClient.get(src, { responseType: 'text' }).pipe(take(1), catchError(() => of(''))).pipe(\n      switchMap((text) => of(this.markdown.render(text))),\n      switchMap((x) => of(this.cleanupEmptyParagraphs(x))),\n      switchMap((x) => of(this.cleanupWasteParagraphFromExampleView(x))),\n      switchMap((x) => of(this.cleanupWasteParagraphFromPreviewGroup(x))),\n      switchMap((x) => of(this.normalizeLinks(x))),\n      switchMap((x) => of(this.domSanitizer.bypassSecurityTrustHtml(x))),\n    );\n  }\n\n  private normalizeLinks(html: string): string {\n    const currentPath = this.router.url;\n    const prefix = currentPath.substring(0, currentPath.lastIndexOf('/'));\n\n    return html.replace(/<a\\s+href=\"([^\"]*)\"/g, (match, href) => {\n      if (!this.isExternalLink(href)) {\n        let newHref = href.substring(0);\n        if (!href.startsWith('./')) {\n          newHref = href.startsWith('/') ? `${ prefix }${ href }` : `${ prefix }/${ href }`;\n        }\n        return `<a href=\"${ newHref }\"`;\n      }\n      return match;\n    });\n  }\n\n  private isExternalLink(href: string): boolean {\n    return href.startsWith('www') || href.startsWith('http');\n  }\n\n  private cleanupEmptyParagraphs(html: string): string {\n    return html.replace(/<p>\\s*<\\/p>/g, '');\n  }\n\n  private cleanupWasteParagraphFromExampleView(html: string): string {\n    return html.replace(/<div class=\"f-code-group-body\">\\s*<p>[^<]*<\\/p>/g, '<div class=\"f-code-group-body\">');\n  }\n\n  private cleanupWasteParagraphFromPreviewGroup(html: string): string {\n    return html.replace(/<p>(\\[[^\\]]+\\](\\s*\\[[^\\]]+\\])*)<\\/p>/g, '');\n  }\n}\n\n"]}

package/esm2022/lib/f-page/f-markdown/domain/markdown/parse-markdown/e-markdown-container-type.mjs

@@ -0,0 +1,13 @@
+export var EMarkdownContainerType;
+(function (EMarkdownContainerType) {
+    EMarkdownContainerType["CODE_GROUP"] = "code-group";
+    EMarkdownContainerType["EXAMPLE_GROUP"] = "ng-component";
+    EMarkdownContainerType["PREVIEW_GROUP"] = "preview-group";
+    EMarkdownContainerType["CODE_VIEW"] = "code-view";
+    EMarkdownContainerType["ALERT_TIP"] = "tip";
+    EMarkdownContainerType["ALERT_INFO"] = "info";
+    EMarkdownContainerType["ALERT_WARNING"] = "warning";
+    EMarkdownContainerType["ALERT_DANGER"] = "danger";
+    EMarkdownContainerType["ALERT_SUCCESS"] = "success";
+})(EMarkdownContainerType || (EMarkdownContainerType = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZS1tYXJrZG93bi1jb250YWluZXItdHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL20tcmVuZGVyL3NyYy9saWIvZi1wYWdlL2YtbWFya2Rvd24vZG9tYWluL21hcmtkb3duL3BhcnNlLW1hcmtkb3duL2UtbWFya2Rvd24tY29udGFpbmVyLXR5cGUudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsTUFBTSxDQUFOLElBQVksc0JBbUJYO0FBbkJELFdBQVksc0JBQXNCO0lBRWhDLG1EQUF5QixDQUFBO0lBRXpCLHdEQUE4QixDQUFBO0lBRTlCLHlEQUErQixDQUFBO0lBRS9CLGlEQUF1QixDQUFBO0lBRXZCLDJDQUFpQixDQUFBO0lBRWpCLDZDQUFtQixDQUFBO0lBRW5CLG1EQUF5QixDQUFBO0lBRXpCLGlEQUF1QixDQUFBO0lBRXZCLG1EQUF5QixDQUFBO0FBQzNCLENBQUMsRUFuQlcsc0JBQXNCLEtBQXRCLHNCQUFzQixRQW1CakMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgZW51bSBFTWFya2Rvd25Db250YWluZXJUeXBlIHtcblxuICBDT0RFX0dST1VQID0gJ2NvZGUtZ3JvdXAnLFxuXG4gIEVYQU1QTEVfR1JPVVAgPSAnbmctY29tcG9uZW50JyxcblxuICBQUkVWSUVXX0dST1VQID0gJ3ByZXZpZXctZ3JvdXAnLFxuXG4gIENPREVfVklFVyA9ICdjb2RlLXZpZXcnLFxuXG4gIEFMRVJUX1RJUCA9ICd0aXAnLFxuXG4gIEFMRVJUX0lORk8gPSAnaW5mbycsXG5cbiAgQUxFUlRfV0FSTklORyA9ICd3YXJuaW5nJyxcblxuICBBTEVSVF9EQU5HRVIgPSAnZGFuZ2VyJyxcblxuICBBTEVSVF9TVUNDRVNTID0gJ3N1Y2Nlc3MnXG59XG4iXX0=

package/esm2022/lib/f-page/f-markdown/domain/markdown/parse-markdown/i-markdown-it-token.mjs

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

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

@@ -0,0 +1,8 @@
+export * from './e-markdown-container-type';
+export * from './i-markdown-it-token';
+export * from './parse-alerts';
+export * from './parse-code-group';
+export * from './parse-code-view';
+export * from './parse-example-group';
+export * from './parse-preview-group';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9tLXJlbmRlci9zcmMvbGliL2YtcGFnZS9mLW1hcmtkb3duL2RvbWFpbi9tYXJrZG93bi9wYXJzZS1tYXJrZG93bi9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLDZCQUE2QixDQUFDO0FBRTVDLGNBQWMsdUJBQXVCLENBQUM7QUFFdEMsY0FBYyxnQkFBZ0IsQ0FBQztBQUUvQixjQUFjLG9CQUFvQixDQUFDO0FBRW5DLGNBQWMsbUJBQW1CLENBQUM7QUFFbEMsY0FBYyx1QkFBdUIsQ0FBQztBQUV0QyxjQUFjLHVCQUF1QixDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9lLW1hcmtkb3duLWNvbnRhaW5lci10eXBlJztcblxuZXhwb3J0ICogZnJvbSAnLi9pLW1hcmtkb3duLWl0LXRva2VuJztcblxuZXhwb3J0ICogZnJvbSAnLi9wYXJzZS1hbGVydHMnO1xuXG5leHBvcnQgKiBmcm9tICcuL3BhcnNlLWNvZGUtZ3JvdXAnO1xuXG5leHBvcnQgKiBmcm9tICcuL3BhcnNlLWNvZGUtdmlldyc7XG5cbmV4cG9ydCAqIGZyb20gJy4vcGFyc2UtZXhhbXBsZS1ncm91cCc7XG5cbmV4cG9ydCAqIGZyb20gJy4vcGFyc2UtcHJldmlldy1ncm91cCc7XG4iXX0=

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

@@ -0,0 +1,19 @@
+import container from 'markdown-it-container';
+export class ParseAlerts {
+    render(type, markdown) {
+        return [container, type, {
+                render: (tokens, index) => {
+                    const token = tokens[index];
+                    const info = token.info.trim().slice(type.length).trim();
+                    if (token.nesting === 1) {
+                        const title = markdown.renderInline(info);
+                        return `<div class="f-alert ${type}"><p class="f-alert-title">${title}</p>\n`;
+                    }
+                    else {
+                        return `</div>\n`;
+                    }
+                }
+            }];
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

@@ -0,0 +1,54 @@
+import container from 'markdown-it-container';
+import { EMarkdownContainerType } from './e-markdown-container-type';
+const F_CONTAINER_CLOSE_TAG = 'container_code-group_close';
+export class ParseCodeGroup {
+    render() {
+        return [container, EMarkdownContainerType.CODE_GROUP, {
+                render: (tokens, index) => {
+                    if (this.isOpeningToken(tokens, index)) {
+                        return this.openingGroupHTML(this.generateTabs(tokens, index));
+                    }
+                    return this.closingGroupHTML();
+                }
+            }];
+    }
+    isOpeningToken(tokens, index) {
+        return tokens[index].nesting === 1;
+    }
+    generateTabs(tokens, index) {
+        let result = '';
+        for (let i = index + 1; !this.isClosingToken(tokens, i); i++) {
+            if (this.isCodeFenceToken(tokens[i])) {
+                const title = this.getCodeBlockTitle(tokens[i].info);
+                if (title) {
+                    result += this.generateTabButton(title);
+                }
+            }
+        }
+        return result;
+    }
+    isClosingToken(token, index) {
+        return token[index].nesting === -1 && token[index].type === F_CONTAINER_CLOSE_TAG;
+    }
+    isCodeFenceToken(token) {
+        return token.type === 'fence' && token.tag === 'code';
+    }
+    generateTabButton(title) {
+        return `<button class="f-tab-button">${title}</button>`;
+    }
+    openingGroupHTML(tabs) {
+        return `<div class="f-code-group"><div class="f-code-group-tabs">${tabs}</div><div class="f-code-group-body">\n`;
+    }
+    closingGroupHTML() {
+        return `</div></div>\n`;
+    }
+    getCodeBlockTitle(data) {
+        return data.match(/\[(.*)\]/)?.[1] || this.getCodeLanguage(data) || 'txt';
+    }
+    getCodeLanguage(data) {
+        return data.trim()
+            .replace(/=(\d*)/, '')
+            .replace(/^ansi$/, '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/f-page/f-markdown/domain/markdown/parse-markdown/parse-code-view.mjs

@@ -0,0 +1,15 @@
+export class ParseCodeView {
+    render(markdown) {
+        const fence = markdown.renderer.rules.fence;
+        if (!fence) {
+            throw new Error('Markdown renderer does not have a fence rule.');
+        }
+        markdown.renderer.rules.fence = (tokens, index, ...rest) => {
+            return (`<div class="f-code-view">${fence(tokens, index, ...rest)}</div>`);
+        };
+    }
+    cleanTokenInfo(info) {
+        return info.replace(/\[.*\]/, '');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFyc2UtY29kZS12aWV3LmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvbS1yZW5kZXIvc3JjL2xpYi9mLXBhZ2UvZi1tYXJrZG93bi9kb21haW4vbWFya2Rvd24vcGFyc2UtbWFya2Rvd24vcGFyc2UtY29kZS12aWV3LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUdBLE1BQU0sT0FBTyxhQUFhO0lBRWpCLE1BQU0sQ0FBQyxRQUFvQjtRQUNoQyxNQUFNLEtBQUssR0FBRyxRQUFRLENBQUMsUUFBUSxDQUFDLEtBQUssQ0FBQyxLQUE0QixDQUFDO1FBQ25FLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztZQUNYLE1BQU0sSUFBSSxLQUFLLENBQUMsK0NBQStDLENBQUMsQ0FBQztRQUNuRSxDQUFDO1FBRUQsUUFBUSxDQUFDLFFBQVEsQ0FBQyxLQUFLLENBQUMsS0FBSyxHQUFHLENBQUMsTUFBMEIsRUFBRSxLQUFhLEVBQUUsR0FBRyxJQUFJLEVBQUUsRUFBRTtZQUNyRixPQUFPLENBQ0wsNEJBQTZCLEtBQUssQ0FBQyxNQUFNLEVBQUUsS0FBSyxFQUFFLEdBQUcsSUFBSSxDQUFFLFFBQVEsQ0FDcEUsQ0FBQztRQUNKLENBQUMsQ0FBQTtJQUNILENBQUM7SUFFTyxjQUFjLENBQUMsSUFBWTtRQUNqQyxPQUFPLElBQUksQ0FBQyxPQUFPLENBQUMsUUFBUSxFQUFFLEVBQUUsQ0FBQyxDQUFDO0lBQ3BDLENBQUM7Q0FDRiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCBNYXJrZG93bkl0IGZyb20gJ21hcmtkb3duLWl0JztcbmltcG9ydCB7IElNYXJrZG93bkl0VG9rZW4gfSBmcm9tICcuL2ktbWFya2Rvd24taXQtdG9rZW4nO1xuXG5leHBvcnQgY2xhc3MgUGFyc2VDb2RlVmlldyB7XG5cbiAgcHVibGljIHJlbmRlcihtYXJrZG93bjogTWFya2Rvd25JdCk6IHZvaWQge1xuICAgIGNvbnN0IGZlbmNlID0gbWFya2Rvd24ucmVuZGVyZXIucnVsZXMuZmVuY2UgYXMgdW5rbm93biBhcyBGdW5jdGlvbjtcbiAgICBpZiAoIWZlbmNlKSB7XG4gICAgICB0aHJvdyBuZXcgRXJyb3IoJ01hcmtkb3duIHJlbmRlcmVyIGRvZXMgbm90IGhhdmUgYSBmZW5jZSBydWxlLicpO1xuICAgIH1cblxuICAgIG1hcmtkb3duLnJlbmRlcmVyLnJ1bGVzLmZlbmNlID0gKHRva2VuczogSU1hcmtkb3duSXRUb2tlbltdLCBpbmRleDogbnVtYmVyLCAuLi5yZXN0KSA9PiB7XG4gICAgICByZXR1cm4gKFxuICAgICAgICBgPGRpdiBjbGFzcz1cImYtY29kZS12aWV3XCI+JHsgZmVuY2UodG9rZW5zLCBpbmRleCwgLi4ucmVzdCkgfTwvZGl2PmBcbiAgICAgICk7XG4gICAgfVxuICB9XG5cbiAgcHJpdmF0ZSBjbGVhblRva2VuSW5mbyhpbmZvOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgIHJldHVybiBpbmZvLnJlcGxhY2UoL1xcWy4qXFxdLywgJycpO1xuICB9XG59XG4iXX0=