@rededor/site-front-end-lib 20.0.27 → 20.0.28

package/fesm2022/rededor-site-front-end-lib-core.mjs

@@ -0,0 +1,1812 @@
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, DOCUMENT, Injectable, signal, PLATFORM_ID, ElementRef, model, HostListener, Directive, input, makeStateKey, TransferState, RESPONSE_INIT } from '@angular/core';
+import { isPlatformBrowser, Location, isPlatformServer } from '@angular/common';
+import { Router } from '@angular/router';
+import { DeviceDetectorService } from 'ngx-device-detector';
+import { catchError, throwError, tap, of, BehaviorSubject, Observable, map } from 'rxjs';
+import { HttpClient, HttpHeaders, HttpResponse } from '@angular/common/http';
+import { differenceInMilliseconds } from 'date-fns';
+import { v4 } from 'uuid';
+import { Title, Meta } from '@angular/platform-browser';
+import * as he from 'he';
+
+// Configura a lib com informações especificas de cada projeto.
+const LIB_CONFIG = new InjectionToken('libConfig');
+
+const REQUEST = new InjectionToken('REQUEST');
+const RESPONSE = new InjectionToken('RESPONSE');
+
+class PhoneService {
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.telRegex = /tel:/;
+        this.phoneModalIsAllowed = true; // variavel utilizada para permitir/bloquear o modal de telefone
+    }
+    /** Verifica se o 'href' é de telefone e se a janela está em tamanho desktop */
+    isPhoneModal(href) {
+        const width = this.document.defaultView?.innerWidth ?? 0;
+        const SMALL_BREAKPOINT = 718;
+        return this.telRegex.test(href) && width > SMALL_BREAKPOINT;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: PhoneService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: PhoneService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: PhoneService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Executa uma função recursivamente até que uma condição seja atendida ou atinja o máximo de tentativas
+ * @param fn - Função a ser executada quando a condição for atendida
+ * @param condition - Função que retorna true quando a condição for satisfeita
+ * @param maxTries - Número máximo de tentativas (padrão: 10)
+ * @param delay - Delay entre tentativas em ms (padrão: 200)
+ * @param currentTry - Contador interno de tentativas (padrão: 0)
+ * @param args - Argumentos que serão passados para a função fn
+ */
+function executeWithRetry(fn, condition, maxTries = 10, delay = 200, currentTry = 0, ...args) {
+    if (!condition() && currentTry < maxTries) {
+        setTimeout(() => {
+            executeWithRetry(fn, condition, maxTries, delay, currentTry + 1, ...args);
+        }, delay);
+    }
+    else {
+        fn(...args);
+    }
+}
+
+class AbstractModalComponent {
+}
+class ModalService {
+    constructor() {
+        this.reference = null;
+        this.firstInteraction = signal(false, ...(ngDevMode ? [{ debugName: "firstInteraction" }] : []));
+        this.maxTries = 10;
+        this.delay = 200;
+    }
+    open() {
+        this.firstInteraction.set(true);
+        executeWithRetry(() => {
+            this.reference?.open();
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setReference(element) {
+        this.reference = element;
+    }
+    setHeader(header) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.modalHeader = header;
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setTitle(title) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.modalTitle = title;
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setContent(content, context = {}) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.modalContent = content;
+                this.reference.modalContentContext = context;
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setActions(actions) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.modalActions = actions;
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setStyle(style) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.componentStyle = style;
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setDefaultPhoneModal(modal) {
+        this.defaultPhoneModal = modal;
+    }
+    close() {
+        executeWithRetry(() => this.reference?.close(), () => !!this.reference, this.maxTries, this.delay);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ModalService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ModalService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ModalService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var RdsiteModalComponentStyle;
+(function (RdsiteModalComponentStyle) {
+    RdsiteModalComponentStyle["DEFAULT"] = "default";
+    RdsiteModalComponentStyle["ALERT"] = "alert";
+    RdsiteModalComponentStyle["LIGHT"] = "light";
+    RdsiteModalComponentStyle["DOCTORCARD"] = "doctor-card";
+    RdsiteModalComponentStyle["HOMESLIDE"] = "home-slide";
+    RdsiteModalComponentStyle["BASIC"] = "basic";
+    RdsiteModalComponentStyle["SHARING"] = "sharing";
+    RdsiteModalComponentStyle["FORMFALLBACK"] = "form-fallback";
+    RdsiteModalComponentStyle["FILTER"] = "filter";
+    RdsiteModalComponentStyle["FILTERDOENCAS"] = "filter-doencas";
+    RdsiteModalComponentStyle["PHOTOGALLERY"] = "photo-gallery";
+})(RdsiteModalComponentStyle || (RdsiteModalComponentStyle = {}));
+
+const formatPhone = (phone) => {
+    if (!phone)
+        return '';
+    const cleanPhone = phone.replace(/[^0-9]/gi, '');
+    let formatedPhone = '';
+    if (cleanPhone.length === 12) {
+        formatedPhone = cleanPhone.replace(/(\d{3})?(\d{5})?(\d{4})/, '($1) $2-$3');
+    }
+    else if (cleanPhone.length === 11) {
+        formatedPhone = cleanPhone.replace(/(\d{2})?(\d{5})?(\d{4})/, '($1) $2-$3');
+    }
+    else if (cleanPhone.length === 10) {
+        formatedPhone = cleanPhone.replace(/(\d{2})?(\d{4})?(\d{4})/, '($1) $2-$3');
+    }
+    else if (cleanPhone.length === 9) {
+        formatedPhone = cleanPhone.replace(/(\d{5})?(\d{4})/, '$1-$2');
+    }
+    else if (cleanPhone.length === 8) {
+        formatedPhone = cleanPhone.replace(/(\d{4})?(\d{4})/, '$1-$2');
+    }
+    else if (cleanPhone.length === 7) {
+        formatedPhone = cleanPhone.replace(/(\d{3})?(\d{4})/, '$1-$2');
+    }
+    else {
+        formatedPhone = cleanPhone;
+    }
+    return formatedPhone;
+};
+
+class RdsitePhoneModalDirective {
+    constructor() {
+        this.modalService = inject(ModalService);
+        this.platformId = inject(PLATFORM_ID);
+        this.element = inject((ElementRef));
+        this.phoneService = inject(PhoneService);
+        this.rdsitephonemodal = model(null, ...(ngDevMode ? [{ debugName: "rdsitephonemodal" }] : []));
+        this.allowedTags = ['A', 'CURA-BUTTON', 'CURA-BUTTON-OUTLINE', 'CURA-BUTTON-TRANSPARENT'];
+    }
+    // Intercepta cliques em telefones e aplica comportamentos diferentes em tamanho desktop.
+    onClick(event) {
+        if (!isPlatformBrowser(this.platformId) || !this.allowedTags.includes(this.element?.nativeElement?.tagName) || !this.phoneService.phoneModalIsAllowed)
+            return;
+        const href = this.element?.nativeElement?.getAttribute('href') ?? '';
+        if (this.phoneService.isPhoneModal(href)) {
+            this.openPhoneModal(event, href);
+        }
+    }
+    openPhoneModal(event, href) {
+        event.preventDefault();
+        event.stopPropagation();
+        this.modalService.setContent(this.rdsitephonemodal() || this.modalService.defaultPhoneModal, { phone: formatPhone(href) });
+        this.modalService.setStyle(RdsiteModalComponentStyle.DEFAULT);
+        this.modalService.open();
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: RdsitePhoneModalDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.18", type: RdsitePhoneModalDirective, isStandalone: true, selector: "[rdsitephonemodal]", inputs: { rdsitephonemodal: { classPropertyName: "rdsitephonemodal", publicName: "rdsitephonemodal", isSignal: true, isRequired: false, transformFunction: null } }, outputs: { rdsitephonemodal: "rdsitephonemodalChange" }, host: { listeners: { "click": "onClick($event)" } }, ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: RdsitePhoneModalDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[rdsitephonemodal]',
+                }]
+        }], propDecorators: { rdsitephonemodal: [{ type: i0.Input, args: [{ isSignal: true, alias: "rdsitephonemodal", required: false }] }, { type: i0.Output, args: ["rdsitephonemodalChange"] }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+
+class RdsiteLinkDirective {
+    constructor() {
+        this.router = inject(Router);
+        this.platformId = inject(PLATFORM_ID);
+        this.document = inject(DOCUMENT);
+        this.libConfig = inject(LIB_CONFIG);
+        this.element = inject((ElementRef));
+        this.phoneService = inject(PhoneService);
+        this.rdsitePhoneModalDirective = inject(RdsitePhoneModalDirective);
+        this.deviceDetectorService = inject(DeviceDetectorService);
+        this.anchorAdjustment = input(null, ...(ngDevMode ? [{ debugName: "anchorAdjustment" }] : []));
+        this.anchorExtraAdjustment = input(null, ...(ngDevMode ? [{ debugName: "anchorExtraAdjustment" }] : []));
+        this.phonemodal = input(null, ...(ngDevMode ? [{ debugName: "phonemodal" }] : []));
+        this.externalRegex = /^http:|https:|tel:|www\.|mailto:/;
+        this.telRegex = /tel:/;
+        this.mailRegex = /mailto:/;
+        this.siteUrlList = ['rededorsaoluiz', 'rededorlabs'];
+        this.allowedTags = ['A', 'CURA-BUTTON', 'CURA-BUTTON-OUTLINE', 'CURA-BUTTON-TRANSPARENT'];
+    }
+    onClick(event) {
+        event.preventDefault();
+        if (!isPlatformBrowser(this.platformId) || !this.allowedTags.includes(this.element?.nativeElement?.tagName))
+            return;
+        let href = this.element?.nativeElement?.getAttribute('href') ?? '';
+        if (!href)
+            return;
+        href = this.verifyUtm(href);
+        if (this.isPhone(href)) {
+            this.phoneClicked({
+                href,
+                event,
+                element: this.element,
+                phonemodal: this.phonemodal(),
+            });
+            return;
+        }
+        const isMobile = this.deviceDetectorService.isMobile();
+        const deviceInfo = this.deviceDetectorService.getDeviceInfo();
+        if (this.isMail(href)) {
+            const target = isMobile || deviceInfo.browser !== 'Chrome' ? '_self' : '_blank';
+            window.open(href, target);
+            return;
+        }
+        if (this.isExternalUrl(href)) {
+            const target = this.isSiteUrl(href) ? '_self' : '_blank';
+            window.open(href, target);
+            return;
+        }
+        if (this.isAnchor(href)) {
+            this.scrollToAnchor(href);
+            return;
+        }
+        this.navigateTo(href);
+    }
+    verifyUtm(href) {
+        if (!href.includes('/paciente'))
+            return href;
+        if (isPlatformBrowser(this.platformId) && typeof window !== 'undefined') {
+            const currentUrl = new URL(window.location.href);
+            const utmParams = Array.from(currentUrl.searchParams.entries()).filter(([key]) => key.startsWith('utm_'));
+            if (utmParams.length === 0)
+                return href;
+            const targetUrl = new URL(href);
+            utmParams.forEach(([key, value]) => targetUrl.searchParams.set(key, value));
+            return targetUrl.toString();
+        }
+        else {
+            return href;
+        }
+    }
+    isPhone(href) {
+        return this.telRegex.test(href);
+    }
+    isMail(href) {
+        return this.mailRegex.test(href);
+    }
+    phoneClicked(value) {
+        const { href, event, element, phonemodal } = value;
+        if (this.phoneService.isPhoneModal(href)) {
+            this.setPhoneModal(element, phonemodal);
+            this.rdsitePhoneModalDirective.openPhoneModal(event, href);
+        }
+        else {
+            window.open(href, '_self');
+        }
+    }
+    setPhoneModal(element, phonemodal) {
+        if (!this.phonemodal())
+            return;
+        if (!this.libConfig?.customPhoneModalCondition) {
+            this.rdsitePhoneModalDirective.rdsitephonemodal.set(phonemodal);
+            return;
+        }
+        if (this.libConfig?.customPhoneModalCondition(element)) {
+            this.rdsitePhoneModalDirective.rdsitephonemodal.set(phonemodal);
+        }
+    }
+    isExternalUrl(href) {
+        return this.externalRegex.test(href);
+    }
+    isSiteUrl(href) {
+        const exception = '/paciente';
+        return this.siteUrlList.find((url) => href.includes(url) && !href.includes(exception));
+    }
+    isAnchor(href) {
+        return href.includes('#');
+    }
+    getAnchor(url) {
+        const hashIndex = url.indexOf('#');
+        return hashIndex !== -1 ? url.substring(hashIndex) : '';
+    }
+    scrollToAnchor(href) {
+        if (href === '#')
+            return;
+        const anchor = this.getAnchor(href);
+        if (isPlatformBrowser(this.platformId)) {
+            const docElement = this.document.documentElement;
+            let adjustment = 0;
+            if (this.libConfig.customAnchorAdjustment) {
+                adjustment = this.libConfig.customAnchorAdjustment(this.document);
+            }
+            if (this.anchorAdjustment()) {
+                adjustment = this.anchorAdjustment();
+            }
+            if (this.anchorExtraAdjustment()) {
+                adjustment += this.anchorExtraAdjustment();
+            }
+            const bodyTop = this.document?.body?.getBoundingClientRect()?.top ?? 0;
+            const hrefTop = this.document?.querySelector(anchor)?.getBoundingClientRect()?.top ?? 0;
+            const scrollTop = bodyTop * -1 + hrefTop - adjustment;
+            docElement.scrollTo({ top: scrollTop, behavior: 'smooth' });
+        }
+    }
+    navigateTo(href) {
+        const siteBasePath = this.libConfig.siteSufix ?? '';
+        const siteBasePathNoSlash = siteBasePath.replace(/\//g, '');
+        let noBaseHref = href;
+        if (!this.libConfig?.skipDuplicationSufixRule) {
+            if (href.startsWith(siteBasePathNoSlash)) {
+                noBaseHref = href.replace(siteBasePathNoSlash, '');
+            }
+            else if (href.startsWith(siteBasePath)) {
+                noBaseHref = href.replace(siteBasePath, '');
+            }
+        }
+        if (this.libConfig?.customInternalLinkNavigation && this.libConfig.customInternalLinkNavigation(noBaseHref)) {
+            return;
+        }
+        const [path, query] = noBaseHref.split('?');
+        const queryParams = {};
+        if (query) {
+            const queryArray = query.split('&');
+            queryArray.forEach((q) => {
+                const arr = q.split('=');
+                queryParams[arr[0]] = arr[1];
+            });
+        }
+        // Força reload da pagina
+        if (this.libConfig?.forcePageReload) {
+            const fullUrl = path + (query ? '?' + query : '');
+            window.location.href = fullUrl;
+            return;
+        }
+        this.router.navigate([path], { queryParams: queryParams });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: RdsiteLinkDirective, deps: [], target: i0.ɵɵFactoryTarget.Directive }); }
+    static { this.ɵdir = i0.ɵɵngDeclareDirective({ minVersion: "17.1.0", version: "20.3.18", type: RdsiteLinkDirective, isStandalone: true, selector: "[rdsitelink]", inputs: { anchorAdjustment: { classPropertyName: "anchorAdjustment", publicName: "anchorAdjustment", isSignal: true, isRequired: false, transformFunction: null }, anchorExtraAdjustment: { classPropertyName: "anchorExtraAdjustment", publicName: "anchorExtraAdjustment", isSignal: true, isRequired: false, transformFunction: null }, phonemodal: { classPropertyName: "phonemodal", publicName: "phonemodal", isSignal: true, isRequired: false, transformFunction: null } }, host: { listeners: { "click": "onClick($event)" } }, providers: [RdsitePhoneModalDirective], ngImport: i0 }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: RdsiteLinkDirective, decorators: [{
+            type: Directive,
+            args: [{
+                    // eslint-disable-next-line @angular-eslint/directive-selector
+                    selector: '[rdsitelink]',
+                    providers: [RdsitePhoneModalDirective],
+                }]
+        }], propDecorators: { anchorAdjustment: [{ type: i0.Input, args: [{ isSignal: true, alias: "anchorAdjustment", required: false }] }], anchorExtraAdjustment: [{ type: i0.Input, args: [{ isSignal: true, alias: "anchorExtraAdjustment", required: false }] }], phonemodal: [{ type: i0.Input, args: [{ isSignal: true, alias: "phonemodal", required: false }] }], onClick: [{
+                type: HostListener,
+                args: ['click', ['$event']]
+            }] } });
+
+var RdsiteModalDrawerComponentStyle;
+(function (RdsiteModalDrawerComponentStyle) {
+    RdsiteModalDrawerComponentStyle["DEFAULT"] = "default";
+    RdsiteModalDrawerComponentStyle["DRAWERDOCTOR"] = "doctor-card";
+    RdsiteModalDrawerComponentStyle["FORMFALLBACK"] = "form-fallback";
+    RdsiteModalDrawerComponentStyle["FILTERDOENCAS"] = "filter-doencas";
+    RdsiteModalDrawerComponentStyle["PHOTOGALLERY"] = "photo-gallery";
+})(RdsiteModalDrawerComponentStyle || (RdsiteModalDrawerComponentStyle = {}));
+
+const getSiteUrl = (siteUrl = '', siteSufix = '') => {
+    const baseUrl = siteUrl.endsWith('/') ? siteUrl.substring(0, siteUrl.length - 1) : siteUrl;
+    const baseSufix = siteSufix.endsWith('/') ? siteSufix.substring(0, siteSufix.length - 1) : siteSufix;
+    return `${baseUrl}${baseSufix}`;
+};
+
+function removeHtmlTags(content) {
+    content = content.replace(/<.*?>/g, '');
+    return content;
+}
+
+const checkSafariAgent = () => {
+    const safariAgent = navigator.userAgent.includes('Safari');
+    const chromeAgent = navigator.userAgent.includes('Chrome');
+    return !chromeAgent && safariAgent;
+};
+
+/**
+ * Função que retorna um replacer personalizado para o JSON.stringify que resolve problemas de estruturas circulares durante a serialização.
+ */
+function getCircularReplacer(customOptions) {
+    const seen = new WeakSet();
+    const options = {
+        ignoreKeys: customOptions?.ignoreKeys || [],
+        maxDepth: customOptions?.maxDepth || 100,
+    };
+    let depth = 0;
+    return (key, value) => {
+        // Ignora chaves específicas configuradas
+        if (options.ignoreKeys.includes(key)) {
+            return undefined;
+        }
+        // Controle de profundidade (opcional)
+        if (key === '') {
+            depth = 0; // Reinicia a profundidade na raiz
+        }
+        else {
+            depth += 1; // Incrementa apenas quando descer na hierarquia
+        }
+        if (depth > options.maxDepth) {
+            return typeof value === 'object' ? '[Object]' : value;
+        }
+        // Lida com referências circulares
+        if (typeof value === 'object' && value !== null) {
+            // Se já vimos este objeto, é uma referência circular
+            if (seen.has(value)) {
+                return undefined; // Exclui valores circulares
+            }
+            // Adiciona o objeto ao conjunto de objetos vistos
+            seen.add(value);
+        }
+        return value;
+    };
+}
+
+/**
+ * Função de hash djb2 para gerar chaves numéricas únicas
+ *
+ * @param str - String para gerar hash
+ * @returns Número hash único e positivo
+ */
+const djb2Hash = (str) => {
+    let hash = 5381; // Valor inicial do djb2 original
+    if (str.length === 0)
+        return hash;
+    for (let i = 0; i < str.length; i++) {
+        const char = str.charCodeAt(i);
+        hash = (hash << 5) + hash + char; // hash * 33 + char
+        hash = hash & hash; // Converte para 32bit integer
+    }
+    return Math.abs(hash);
+};
+
+class LogService {
+    constructor() {
+        this.libConfig = inject(LIB_CONFIG);
+        this.platformId = inject(PLATFORM_ID);
+        this.location = inject(Location);
+    }
+    logMsg(msg, label) {
+        label = label ? `${label} ` : '';
+        if (!isPlatformBrowser(this.platformId) || (isPlatformBrowser(this.platformId) && !this.libConfig?.production)) {
+            console.log(`${label}${msg}`);
+        }
+    }
+    logLoad(component) {
+        this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, 'LOAD');
+    }
+    log404(component) {
+        this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, '404');
+    }
+    log500(component) {
+        this.logMsg(`${this.getPageURL()}${component ? ' - ' + component : ''}`, '500');
+    }
+    getPageURL() {
+        return `${getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix)}${this.location.path()}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: LogService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: LogService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: LogService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Converte JSON para query string.
+ * @param params JSON
+ */
+function toQueryParams(params) {
+    return params
+        ? `?${Object.keys(params)
+            .map((key) => key + '=' + params[key])
+            .join('&')}`
+        : '';
+}
+
+/* Adiciona os Headers necessários para funcionamento do site back-end */
+class HttpClientService {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.libConfig = inject(LIB_CONFIG);
+        this.http = inject(HttpClient);
+        this.deviceService = inject(DeviceDetectorService);
+    }
+    get(url) {
+        const headers = this.getHeaders();
+        return this.http.get(url, { headers });
+    }
+    post(url, data) {
+        const headers = this.getHeaders();
+        return this.http.post(url, data, { headers });
+    }
+    getHeaders() {
+        const baseHeaders = new HttpHeaders()
+            .set('x-origin-application', this.libConfig.xOriginApplication)
+            .set('x-origin-channel', this.getOriginChannel())
+            .set('x-origin-device', this.getOriginDevice());
+        if (isPlatformServer(this.platformId) && this.libConfig.server) {
+            return baseHeaders.append('authorization', 'Basic ' + Buffer.from(`${this.libConfig.siteApi.auth.user}:${this.libConfig.siteApi.auth.password}`).toString('base64'));
+        }
+        else {
+            return baseHeaders.append('client_id', this.libConfig.client_id);
+        }
+    }
+    getOriginChannel() {
+        return this.deviceService.isDesktop() ? 'desktop' : 'mobile';
+    }
+    getOriginDevice() {
+        return `app-${this.deviceService.getDeviceInfo().os}`;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: HttpClientService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: HttpClientService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: HttpClientService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+
+class SiteBackendService {
+    constructor() {
+        this.httpClientService = inject(HttpClientService);
+        this.libConfig = inject(LIB_CONFIG);
+        this.platformId = inject(PLATFORM_ID);
+        this.siteApiUrl = this.getApiUrl();
+    }
+    getApiUrl() {
+        if (isPlatformServer(this.platformId) && this.libConfig.server) {
+            return this.libConfig.siteApi.baseInternal;
+        }
+        return this.libConfig.siteApi.base;
+    }
+    /**
+     * GET para qualquer endpoint do back-end do site.
+     * @param path - O caminho do recurso. (Inicia sem '/'. Ex: 'unidades/wp')
+     * @param params - Parâmetros opcionais para a requisição.
+     * @returns Observable que emite os dados retornados pelo back-end.
+     */
+    get(path, params) {
+        return this.httpClientService.get(`${this.siteApiUrl}${path}${toQueryParams(params)}`);
+    }
+    /**
+     * POST para qualquer endpoint do back-end do site.
+     * @param path - O caminho do recurso. (Inicia sem '/'. Ex: 'unidades/wp')
+     * @param params - Parâmetros opcionais para a requisição.
+     * @returns Observable que emite os dados retornados pelo back-end.
+     */
+    post(path, params) {
+        return this.httpClientService.post(`${this.siteApiUrl}${path}`, params);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SiteBackendService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SiteBackendService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SiteBackendService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class ErrorInterceptor {
+    constructor() {
+        this.logService = inject(LogService);
+        this.siteBackendService = inject(SiteBackendService);
+        this.platformId = inject(PLATFORM_ID);
+    }
+    intercept(req, next) {
+        const queryParams = req.params.keys().length ? `?${req.params.toString()}` : '';
+        const requestUrl = `${req.url}${queryParams}`;
+        return next.handle(req).pipe(catchError((error) => {
+            this.logService.logMsg(`REQUEST ERROR => ${req.method} ${requestUrl}`, 'ERROR_INTERCEPTOR');
+            if (isPlatformBrowser(this.platformId) && !req.url.includes('/log/error')) {
+                const errorMessage = typeof error === 'string' ? error : error instanceof Error ? error.message : JSON.stringify(error);
+                this.siteBackendService
+                    .post('log/error', {
+                    error: errorMessage,
+                    origin: window.location.href,
+                    url: req.urlWithParams,
+                })
+                    .subscribe();
+            }
+            return throwError(() => error);
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ErrorInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ErrorInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ErrorInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class LogInterceptor {
+    constructor() {
+        this.logService = inject(LogService);
+    }
+    intercept(req, next) {
+        const requestId = v4();
+        const startTime = Date.now();
+        const queryParams = req.params.keys().length ? `?${req.params.toString()}` : '';
+        const requestUrl = `${req.url}${queryParams}`;
+        this.logService.logMsg(`REQUEST ${requestId} => ${req.method} ${requestUrl}`, 'INTERCEPTOR');
+        return next.handle(req).pipe(tap((response) => {
+            const res = response;
+            if (res?.status) {
+                const elapsedTime = differenceInMilliseconds(Date.now(), startTime);
+                this.logService.logMsg(`RESPONSE ${requestId} => ${req.method} ${requestUrl} | Duração: ${elapsedTime}ms | Status: ${res.status} - ${res.statusText} | Body: ${!!res.body}`, 'INTERCEPTOR');
+            }
+        }));
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: LogInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: LogInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: LogInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Cria uma chave numérica única para o cache
+ * Gera um hash baseado em método + URL + parâmetros
+ */
+function createCacheKey(req, url) {
+    const method = req.method;
+    const params = req.params.toString();
+    // Combina método, URL e parâmetros
+    const keyString = [method, url, params].filter((part) => part.length > 0).join('::');
+    // Gera hash numérico único
+    const hashNumber = djb2Hash(keyString);
+    return hashNumber.toString();
+}
+/**
+ * Cria StateKey para o TransferState
+ */
+function getTransferStateKey(req, url) {
+    const cacheKey = createCacheKey(req, url);
+    return makeStateKey(cacheKey);
+}
+/**
+ * Interceptor para resolver o problema de TransferState com urls diferentes
+ *
+ * Problema: O SiteBackendService usa urls diferentes no server (baseInternal) e no client (base), fazendo com que o TransferState nativo do Angular não funcione corretamente.
+ *
+ * Solução:
+ * - Server: Usa url interna, mas salva no TransferState baseado na url externa
+ * - Client: Verifica TransferState usando url externa antes de fazer alguma requisição
+ *
+ * Dessa forma é possivel fazer o uso do TransferState mesmo com urls diferentes ("baseInternal" no server e "base" no client).
+ */
+class TransferStateUrlInterceptor {
+    constructor() {
+        this.platformId = inject(PLATFORM_ID);
+        this.transferState = inject(TransferState);
+        this.libConfig = inject(LIB_CONFIG);
+    }
+    intercept(req, next) {
+        if (isPlatformServer(this.platformId)) {
+            return this.handleServerRequest(req, next);
+        }
+        else if (isPlatformBrowser(this.platformId)) {
+            return this.handleClientRequest(req, next);
+        }
+        return next.handle(req);
+    }
+    /**
+     * Filtra headers da resposta baseado na configuração no LibConfig
+     */
+    filterHeaders(responseHeaders) {
+        const includeHeaders = this.libConfig.transferState?.includeHeaders;
+        if (!includeHeaders || includeHeaders.length === 0) {
+            return {};
+        }
+        // Filtra apenas os headers configurados
+        const filteredHeaders = {};
+        includeHeaders.forEach((headerName) => {
+            const headerValue = responseHeaders.get(headerName.toLowerCase());
+            if (headerValue) {
+                filteredHeaders[headerName.toLowerCase()] = headerValue;
+            }
+        });
+        return filteredHeaders;
+    }
+    handleServerRequest(req, next) {
+        const siteApi = this.libConfig.siteApi;
+        // Para urls internas
+        if (req.url.startsWith(siteApi.baseInternal)) {
+            const externalUrl = req.url.replace(siteApi.baseInternal, siteApi.base);
+            const stateKey = getTransferStateKey(req, externalUrl);
+            return next.handle(req).pipe(tap((event) => {
+                if (event instanceof HttpResponse) {
+                    const filteredHeaders = this.filterHeaders(event.headers);
+                    // Salva no TransferState baseado na url externa
+                    this.transferState.set(stateKey, {
+                        body: event.body,
+                        status: event.status,
+                        statusText: event.statusText,
+                        headers: filteredHeaders,
+                    });
+                }
+            }));
+        }
+        return next.handle(req);
+    }
+    handleClientRequest(req, next) {
+        const siteApi = this.libConfig.siteApi;
+        // Para urls externas
+        if (req.url.startsWith(siteApi.base)) {
+            const stateKey = getTransferStateKey(req, req.url);
+            const cachedResponse = this.transferState.get(stateKey, null);
+            if (cachedResponse) {
+                this.transferState.remove(stateKey);
+                // Retorna resposta do TransferState
+                return of(new HttpResponse({
+                    body: cachedResponse.body,
+                    status: cachedResponse.status,
+                    statusText: cachedResponse.statusText,
+                    headers: cachedResponse.headers,
+                }));
+            }
+        }
+        return next.handle(req);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: TransferStateUrlInterceptor, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: TransferStateUrlInterceptor, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: TransferStateUrlInterceptor, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var EnumDoencaTaxonomy;
+(function (EnumDoencaTaxonomy) {
+    EnumDoencaTaxonomy["DOENCAS_CAT"] = "doencas_cat";
+    EnumDoencaTaxonomy["DOENCAS_TAG"] = "doencas_tag";
+})(EnumDoencaTaxonomy || (EnumDoencaTaxonomy = {}));
+var EnumDoencaTaxonomyCat;
+(function (EnumDoencaTaxonomyCat) {
+    EnumDoencaTaxonomyCat["DOENCA"] = "doencas";
+    EnumDoencaTaxonomyCat["SINTOMA"] = "sintomas";
+})(EnumDoencaTaxonomyCat || (EnumDoencaTaxonomyCat = {}));
+
+var FilterType;
+(function (FilterType) {
+    FilterType["INPUT"] = "input";
+    FilterType["SELECT"] = "select";
+    FilterType["CHECKBOX_GROUP"] = "checkbox-group";
+    FilterType["RADIO_GROUP"] = "radio-group";
+    FilterType["CUSTOM"] = "custom";
+})(FilterType || (FilterType = {}));
+
+class ErrorService {
+    constructor() {
+        this.ctas = new BehaviorSubject({});
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ErrorService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ErrorService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ErrorService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class MapBoxService {
+    constructor() {
+        this.http = inject(HttpClient);
+        this.logService = inject(LogService);
+        this.libConfig = inject(LIB_CONFIG);
+        this.platformId = inject(PLATFORM_ID);
+        this.mapboxAccessToken = this.libConfig.mapboxAccessToken;
+        this.mapboxSSRAccessToken = this.libConfig.mapboxSSRAccessToken;
+        this.mapboxApiUrl = 'https://api.mapbox.com';
+        this.geocodingEp = 'search/geocode/v6';
+    }
+    /**
+     * Busca geocalizada por nome do local.
+     * Ex.: barra da tijuca, rio de janeiro - rio de janeiro, brasil
+     * @param query nome de local para a busca
+     * @param params parâmetros opcionais de busca e filtro
+     */
+    forwardGeocoding(query, params = {}, logContext) {
+        this.logMapbox('forwardGeocoding', logContext);
+        if (query.length >= 256) {
+            return throwError(() => 'Query length exceeds 255 characters.');
+        }
+        const url = `${this.mapboxApiUrl}/${this.geocodingEp}/forward?q=${query}`;
+        params['access_token'] = isPlatformBrowser(this.platformId) ? this.mapboxAccessToken : this.mapboxSSRAccessToken;
+        return this.http.get(url, { params, headers: this.getHeaders() });
+    }
+    /**
+     * Busca local por longitude e latitude
+     * @param lng formato longitude
+     * @param lat formato latitude
+     * @param params parâmetros opcionais de busca e filtro
+     */
+    reverseGeocoding(lng, lat, params = {}, logContext) {
+        this.logMapbox('reverseGeocoding', logContext);
+        const url = `${this.mapboxApiUrl}/${this.geocodingEp}/reverse?longitude=${lng}&latitude=${lat}`;
+        params['access_token'] = isPlatformBrowser(this.platformId) ? this.mapboxAccessToken : this.mapboxSSRAccessToken;
+        return this.http.get(url, { params });
+    }
+    logMapbox(callerFunction, context = 'no-context') {
+        const platform = isPlatformServer(this.platformId) ? 'server' : 'browser';
+        this.logService.logMsg(`${platform} - ${callerFunction} - ${context}`, 'MAPBOX');
+    }
+    getHeaders() {
+        return new HttpHeaders().set('Referrer-Policy', 'origin');
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: MapBoxService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: MapBoxService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: MapBoxService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+var GeolocationPermissions;
+(function (GeolocationPermissions) {
+    GeolocationPermissions["GRANTED"] = "granted";
+    GeolocationPermissions["PROMPT"] = "prompt";
+    GeolocationPermissions["DENIED"] = "denied";
+})(GeolocationPermissions || (GeolocationPermissions = {}));
+class GeolocService {
+    get switchStatus() {
+        return this._switchStatus;
+    }
+    get address() {
+        return this._address;
+    }
+    get permission() {
+        return this._permission;
+    }
+    get disableSwitch() {
+        return this._disableSwitch;
+    }
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.platformId = inject(PLATFORM_ID);
+        this.mapboxService = inject(MapBoxService);
+        this.logService = inject(LogService);
+        this._mapboxGeocodingParams = {
+            types: 'place',
+            limit: 1,
+            language: 'pt-BR',
+            country: 'BR',
+        };
+        this._hasConsent = false;
+        this._switchStatus = false;
+        this._address = null;
+        this._permission = GeolocationPermissions.PROMPT;
+        this.geolocation = new BehaviorSubject(null);
+        this.isChecked = new BehaviorSubject(false); // Emite true quando o geoloc está estável
+        this._isSafariAgent = false;
+        this._disableSwitch = false;
+        if (isPlatformServer(this.platformId)) {
+            this.isChecked.next(true);
+            return;
+        }
+        this._isSafariAgent = checkSafariAgent();
+        if (this._isSafariAgent) {
+            this._hasConsent = this.checkACookieExists('geolocation_consent');
+            this.initGeolocation(this._hasConsent);
+            return;
+        }
+        navigator?.permissions
+            ?.query({ name: 'geolocation' })
+            .then((permission) => {
+            this._permission = permission.state;
+            this.initGeolocation(this._permission === GeolocationPermissions.GRANTED);
+            permission.onchange = () => {
+                this._permission = permission.state;
+                this.initGeolocation(this._permission === GeolocationPermissions.GRANTED);
+            };
+        })
+            .catch((error) => {
+            this.logService.logMsg(JSON.stringify(error, getCircularReplacer()), 'ERROR');
+            this._permission = GeolocationPermissions.DENIED;
+            this._disableSwitch = true;
+            this.initGeolocation(false);
+        });
+    }
+    initGeolocation(geolocAllowed = false) {
+        this._switchStatus = true;
+        if (geolocAllowed) {
+            this.getCurrentPosition().subscribe({
+                next: (position) => {
+                    this._disableSwitch = false;
+                    this.setGeolocation(position);
+                    this.setConsentCookie(true, 3650);
+                    this._hasConsent = true;
+                    this._permission = GeolocationPermissions.GRANTED;
+                },
+                error: () => {
+                    if (this._permission === GeolocationPermissions.DENIED) {
+                        this._disableSwitch = true;
+                        this.setConsentCookie(false, 15);
+                    }
+                    this.geolocation.next(null);
+                    this._address = null;
+                    this._hasConsent = false;
+                    this._switchStatus = false;
+                    this.isChecked.next(true);
+                },
+            });
+        }
+        else {
+            if (this.permission === GeolocationPermissions.DENIED) {
+                this._disableSwitch = true;
+                this.setConsentCookie(false, 15);
+            }
+            this.geolocation.next(null);
+            this._address = null;
+            this._hasConsent = false;
+            this._switchStatus = false;
+            this.isChecked.next(true);
+        }
+    }
+    getCurrentPosition() {
+        return new Observable((observer) => {
+            navigator.geolocation.getCurrentPosition((position) => {
+                observer.next(position);
+                observer.complete();
+            }, (error) => observer.error(error), { enableHighAccuracy: true });
+        });
+    }
+    setGeolocation(position) {
+        if (position) {
+            if (position.coords.latitude === this.geolocation.value?.lat && position.coords.longitude === this.geolocation.value?.lng)
+                return;
+            this.geolocation.next({
+                lat: position.coords.latitude,
+                lng: position.coords.longitude,
+            });
+            this.getMapboxAdress()
+                .pipe(map((response) => {
+                const city = response?.features[0]?.properties?.name;
+                const state = {
+                    name: response?.features[0]?.properties?.context?.region?.name,
+                    shortCode: response?.features[0]?.properties?.context?.region?.region_code,
+                };
+                return { city, state };
+            }))
+                .subscribe({
+                next: (response) => {
+                    this._address = response;
+                    this._switchStatus = true;
+                    this.isChecked.next(true);
+                },
+                error: (error) => {
+                    this.logService.logMsg(JSON.stringify(error, getCircularReplacer()), 'ERROR');
+                    this._switchStatus = false;
+                    this.geolocation.next(null);
+                    this._address = null;
+                    this.isChecked.next(true);
+                },
+            });
+        }
+        else {
+            this.geolocation.next(null);
+            this._address = null;
+            this._switchStatus = false;
+            this.isChecked.next(true);
+        }
+    }
+    getMapboxAdress() {
+        const lng = `${this.geolocation.value?.lng}`;
+        const lat = `${this.geolocation.value?.lat}`;
+        return this.mapboxService.reverseGeocoding(lng, lat, this._mapboxGeocodingParams, 'geolocalizacao.service getMapboxAdress');
+    }
+    checkACookieExists(name) {
+        if (isPlatformServer(this.platformId) || typeof this.document === 'undefined' || !this.document?.cookie) {
+            return false;
+        }
+        return this.document.cookie
+            .split(';')
+            .map((item) => item.trim())
+            .some((item) => item.trim().startsWith(name));
+    }
+    setConsentCookie(status, days) {
+        if (this.getCookieValue('geolocation_consent') !== status.toString()) {
+            const lifetime = new Date(Date.now() + days * 86400000).toUTCString();
+            this.document.cookie = `geolocation_consent=${status}; path=/; expires=${lifetime}; SameSite=None; Secure`;
+        }
+    }
+    getCookieValue(prop) {
+        if (isPlatformBrowser(this.platformId)) {
+            const value = this.document.cookie
+                .split(';')
+                .map((item) => item.trim())
+                .find((item) => item.startsWith(`${prop}=`));
+            return value ? value.slice(prop.length + 1) : '';
+        }
+        return '';
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: GeolocService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: GeolocService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: GeolocService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }], ctorParameters: () => [] });
+
+class AbstractModalDrawerComponent {
+}
+class ModalDrawerService {
+    constructor() {
+        this.reference = null;
+        this.firstInteraction = signal(false, ...(ngDevMode ? [{ debugName: "firstInteraction" }] : []));
+        this.maxTries = 10;
+        this.delay = 200;
+    }
+    open() {
+        this.firstInteraction.set(true);
+        executeWithRetry(() => {
+            this.reference?.openSheet();
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setReference(element) {
+        this.reference = element;
+    }
+    setContent(content) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.modalContent?.set(content);
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setStyle(style) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.componentStyle.set(style);
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    setHeight(value) {
+        executeWithRetry(() => {
+            if (this.reference) {
+                this.reference.maxHeight = value;
+            }
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    close() {
+        executeWithRetry(() => {
+            this.reference?.closeSheet();
+        }, () => !!this.reference, this.maxTries, this.delay);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ModalDrawerService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ModalDrawerService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ModalDrawerService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class PrivacyToolsService {
+    constructor() {
+        this.document = inject(DOCUMENT);
+        this.platformId = inject(PLATFORM_ID);
+        this.cookieBannerScriptId = 'PrivacyToolsScript';
+        this.cookieBannerStyleId = 'PrivacyToolsStyle';
+        this.cookieBannerScriptElement = null;
+        this.configOptions = {};
+        this.cookieConsent = null;
+    }
+    /* Config */
+    config(options) {
+        this.configOptions = options;
+    }
+    /* Setup cookie Banner */
+    setupCookieBanner(unidadeBasePath) {
+        if (isPlatformBrowser(this.platformId)) {
+            const banner = this.configOptions?.cookieBanners?.find((banner) => banner.basePath.includes(unidadeBasePath));
+            if (banner) {
+                this.addCookieBanner(banner);
+            }
+        }
+    }
+    openCookieBanner() {
+        if (this.cookieConsent && this.cookieBannerScriptElement) {
+            this.cookieConsent.privacyToolsShowCookieNotice();
+        }
+    }
+    /* Add cookie banner style and script */
+    addCookieBanner(banner) {
+        this.cookieBannerScriptElement = null;
+        this.addCookieBannerStyle(banner.styleSrc);
+        this.addCookieBannerScript(banner.scriptSrc);
+    }
+    /* Add cookie banner style. */
+    addCookieBannerStyle(src) {
+        if (isPlatformServer(this.platformId))
+            return;
+        this.document.getElementById('byRemovePortal')?.remove();
+        const oldStyle = this.document.getElementById(this.cookieBannerStyleId);
+        if (oldStyle) {
+            oldStyle.remove();
+        }
+        const style = this.document.createElement('link');
+        style.id = this.cookieBannerStyleId;
+        style.rel = 'stylesheet';
+        style.type = 'text/css';
+        style.href = src;
+        style.media = 'none';
+        style.addEventListener('load', () => {
+            style.media = 'all';
+        });
+        this.document.body.appendChild(style);
+    }
+    /* Add cookie banner script. */
+    addCookieBannerScript(src) {
+        if (isPlatformServer(this.platformId) || typeof window === 'undefined')
+            return;
+        window['cookieconsent'] = null;
+        const oldScript = this.document.getElementById(this.cookieBannerScriptId);
+        if (oldScript) {
+            oldScript.remove();
+        }
+        const script = this.document.createElement('script');
+        script.id = this.cookieBannerScriptId;
+        script.src = src;
+        script.addEventListener('load', () => {
+            this.cookieBannerScriptElement = script;
+            this.cookieConsent = window['cookieconsent'];
+            window['portalBanner']?.call();
+        });
+        this.document.body.appendChild(script);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: PrivacyToolsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: PrivacyToolsService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: PrivacyToolsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class SeoService {
+    constructor() {
+        this.title = inject(Title);
+        this.meta = inject(Meta);
+        this.location = inject(Location);
+        this.libConfig = inject(LIB_CONFIG);
+        this.document = inject(DOCUMENT);
+        this.separator = ' - ';
+        this.defaultTitle = 'Rede D’Or';
+        this.sameAs = [
+            'https://www.facebook.com/rededor/',
+            'https://www.instagram.com/rededor_oficial/',
+            'https://www.linkedin.com/company/rededor-saoluiz',
+            'https://twitter.com/rededor',
+        ];
+        this.twitterUser = '@rededor';
+        this.jsonTagId = 'seoJSON';
+        this.breadcrumbsJsonTagId = 'breadcrumbsJSON';
+        this.unidade = null;
+        this.unidadeName = '';
+        this.unidadePath = '';
+        this.unidadeSlug = '';
+        this.customJsonType = [];
+    }
+    setFullSeo(data) {
+        this.setTitle(data.title.text, !!data.title.sub);
+        this.setDescription(data.description);
+        this.setCanonicalHref(data.canonical);
+        this.setPageJson();
+        this.setSocialTags(data.socialTags);
+    }
+    /**
+     * Define tag description da página
+     * @param content conteúdo da descrição <string>
+     */
+    setDescription(content) {
+        const descTag = this.meta.getTag("name='description'");
+        if (content) {
+            content = he.decode(content);
+            content = removeHtmlTags(content);
+        }
+        else {
+            content = '';
+        }
+        this.activeDescription = content;
+        const tagContent = { name: 'description', content };
+        if (descTag) {
+            this.meta.updateTag(tagContent);
+        }
+        else {
+            this.meta.addTag(tagContent);
+        }
+        return this;
+    }
+    /**
+     * Define meta tags para a página
+     * @param tag nome da tag meta
+     * @param content conteúdo da tag meta
+     * @param type tipo de tag meta
+     */
+    setMetaTag(tag, content, type = 'name') {
+        const metatag = this.meta.getTag(`${type}='${tag}'`);
+        content = he.decode(content);
+        content = removeHtmlTags(content);
+        const tagContent = {
+            [type]: tag,
+            content,
+        };
+        if (!metatag) {
+            this.meta.addTag(tagContent);
+        }
+        else {
+            this.meta.updateTag(tagContent);
+        }
+        return this;
+    }
+    /**
+     * Remove meta tags da página
+     * @param tag nome da tag meta
+     * @param content conteúdo da tag meta
+     * @param attr atributo da tag meta
+     * @param type tipo de tag meta
+     */
+    removeTag(tag, content, attr, type = 'name') {
+        const metatag = this.meta.getTag(`${type}='${tag}'`);
+        if (metatag) {
+            this.meta.removeTag(`${attr}=${content}`);
+        }
+        return this;
+    }
+    /**
+     * Define meta tags para Facebook
+     * @param title título para o facebook
+     * @param description descrição para o facebook
+     * @param url url para definição do facebook
+     * @param img imagem para definição no facebook
+     */
+    setMetaFacebook(title, description, url, img = null) {
+        this.setMetaTag('og:url', url, 'property');
+        this.setMetaTag('og:title', title, 'property');
+        this.setMetaTag('og:description', description, 'property');
+        this.setMetaTag('og:type', 'website', 'property');
+        this.setMetaTag('og:image', img ?? '', 'property');
+    }
+    /**
+     * Define meta tags para Twitter
+     * @param title título para o twitter
+     * @param description descrição para o twitter
+     * @param url url para o twitter
+     * @param img imagem para definição no twitter
+     */
+    setMetaTwitter(title, description, url, img = null) {
+        this.setMetaTag('twitter:site', url, 'name');
+        this.setMetaTag('twitter:title', title, 'name');
+        this.setMetaTag('twitter:description', description, 'name');
+        this.setMetaTag('twitter:image', img ?? '', 'name');
+    }
+    /**
+     * Define tags de redes sociais (Twitter e Open Graph)
+     * @param properties
+     */
+    setSocialTags(properties) {
+        const pagePath = this.location.path();
+        const siteurl = getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix);
+        let defaultProperties = {
+            twitterCard: 'summary',
+            twitterSite: this.twitterUser,
+            type: 'website',
+            title: this.getTitle(),
+            description: this.activeDescription || '',
+            url: `${siteurl}${pagePath}`,
+            image: this.libConfig?.logoPath ? `${siteurl}${this.libConfig.logoPath}` : 'https://www.rededorsaoluiz.com.br/assets/imgs/logo-rededor-blue.png',
+        };
+        if (properties) {
+            defaultProperties = { ...defaultProperties, ...properties };
+        }
+        this.setMetaTag('twitter:card', defaultProperties.twitterCard || '', 'name')
+            .setMetaTag('twitter:site', defaultProperties.twitterSite || '', 'name')
+            .setMetaTag('og:type', defaultProperties.type || '', 'property')
+            .setMetaTag('og:title', defaultProperties.title || '', 'property')
+            .setMetaTag('og:description', defaultProperties.description || '', 'property')
+            .setMetaTag('og:url', defaultProperties.url || '', 'property')
+            .setMetaTag('og:image', defaultProperties.image || '', 'property');
+        return this;
+    }
+    /**
+     * Define título da página
+     * @param title título da página <string>
+     * @param sub Se é subsite acrescenta unidade <boolean>
+     */
+    setTitle(title, sub = false) {
+        if (title && title !== '') {
+            title = he.decode(title);
+            title = removeHtmlTags(title);
+            if (sub) {
+                title = he.decode(`${title}${this.separator}${this.unidadeName}`);
+            }
+            this.title.setTitle(title);
+        }
+        return this;
+    }
+    /** Obtem título atual da página */
+    getTitle() {
+        return this.title.getTitle();
+    }
+    set404Title(component = 'Default Component') {
+        if (component && component !== '') {
+            component = he.decode(component);
+            component = removeHtmlTags(component);
+            if (this.unidadeName) {
+                component = he.decode(`${component}${this.separator}${this.unidadeName}`);
+            }
+        }
+        const title = `Erro 404 - ${component} - ${this.libConfig?.siteName} - ${this.location.path()}`;
+        this.title.setTitle(title);
+        return this;
+    }
+    set500Title(component = 'Default Component') {
+        if (component && component !== '') {
+            component = he.decode(component);
+            component = removeHtmlTags(component);
+            if (this.unidadeName) {
+                component = he.decode(`${component}${this.separator}${this.unidadeName}`);
+            }
+        }
+        const title = `Erro 500 - ${component} - ${this.libConfig?.siteName} - ${this.location.path()}`;
+        this.title.setTitle(title);
+        return this;
+    }
+    /** Cria tag script para JSON de breadcrumbs */
+    createBreadcrumbsJSONTag() {
+        const tag = this.document.createElement('script');
+        tag.id = this.breadcrumbsJsonTagId;
+        tag.type = 'application/ld+json';
+        this.document.head.appendChild(tag);
+        this.breadcrumbsJsonTag = tag;
+        return tag;
+    }
+    /** Retorna tag para script json de breadcrumbs ou cria se não houver. */
+    getBreadcrumbsJSONTag() {
+        const elements = this.document.head.children;
+        let i;
+        for (i = 0; i < elements.length; i++) {
+            const elem = elements[i];
+            if (elem && elem.id === this.breadcrumbsJsonTagId) {
+                return elem;
+            }
+        }
+        return this.createBreadcrumbsJSONTag();
+    }
+    /** Define o JSON de breadcrumbs da página */
+    setBreadcrumbsJson(items) {
+        this.breadcrumbsJsonTag = this.getBreadcrumbsJSONTag();
+        const json = {
+            '@context': 'http://schema.org',
+            '@type': 'BreadcrumbList',
+            itemListElement: this.getJsonBreadcrumbItems(items),
+        };
+        this.breadcrumbsJsonTag.innerHTML = JSON.stringify(json);
+        return this;
+    }
+    /** Converte itens do breadcrumb em itens do JSON */
+    getJsonBreadcrumbItems(items) {
+        const jsonItems = [
+            {
+                '@type': 'ListItem',
+                position: 1,
+                item: { '@id': this.getBreadcrumbItemUrl(['/']), name: he.encode('Página Inicial') },
+            },
+        ];
+        items.forEach((item, i) => {
+            const jsonItem = {
+                '@type': 'ListItem',
+                position: i + 2,
+                item: { '@id': this.getBreadcrumbItemUrl(item?.url || []), name: he.encode(item.label) },
+            };
+            jsonItems.push(jsonItem);
+        });
+        return jsonItems;
+    }
+    /**
+     * Monta a url do item de breadcrumb proveniente do array de urls
+     * ou do caminho da própria página, conforme caso do último item.
+     */
+    getBreadcrumbItemUrl(url) {
+        const siteurl = getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix);
+        if (!url || url.length <= 0) {
+            const pagePath = this.location.path();
+            return `${siteurl}${pagePath}`;
+        }
+        url = url.filter((u) => u !== this.unidadePath);
+        const unidadePath = this.getUnidadePath();
+        const fullPath = `${unidadePath}/${url.join('/').replace(/^\/?/, '')}`;
+        return `${siteurl}${fullPath}`.replace(/\/$/, '');
+    }
+    /** Cria tag script para o JSON de SEO */
+    createJSONTag() {
+        const tag = this.document.createElement('script');
+        tag.id = this.jsonTagId;
+        tag.type = 'application/ld+json';
+        this.document.head.appendChild(tag);
+        this.jsonTag = tag;
+        return tag;
+    }
+    /** Retorna tag para script json de breadcrumbs ou cria se não houver. */
+    getJSONTag() {
+        const elements = this.document.head.children;
+        let i;
+        for (i = 0; i < elements.length; i++) {
+            const elem = elements[i];
+            if (elem && elem.id === this.jsonTagId) {
+                return elem;
+            }
+        }
+        return this.createJSONTag();
+    }
+    /** Define JSON para SEO somente quando no servidor */
+    setPageJson() {
+        this.jsonTag = this.getJSONTag();
+        const baseGraph = [this.getOrgJson(), this.getWebsiteJson(), this.getWebpageJson()];
+        const extendedGraph = this.customJsonType.length ? [...baseGraph, ...this.customJsonType] : baseGraph;
+        this.customJsonType = [];
+        const json = {
+            '@context': 'http://schema.org',
+            '@graph': extendedGraph,
+        };
+        this.jsonTag.innerHTML = JSON.stringify(json);
+        return this;
+    }
+    /** Obtem JSON da Organização */
+    getOrgJson() {
+        const siteurl = getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix);
+        return {
+            '@type': 'Organization',
+            '@id': `${siteurl}#organization`,
+            name: this.defaultTitle,
+            keywords: this.libConfig?.keywords,
+            url: `${siteurl}`,
+            sameAs: this.sameAs,
+        };
+    }
+    /** Obtem JSON do Website (portal, unidades, etc) */
+    getWebsiteJson() {
+        const unidadePath = this.getUnidadePath();
+        const siteurl = getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix);
+        return {
+            '@type': 'WebSite',
+            '@id': `${siteurl}${unidadePath}#website`,
+            url: `${siteurl}${unidadePath}`,
+            name: this.unidadeName,
+            keywords: this.libConfig?.keywords,
+        };
+    }
+    /** Obtem Json da página */
+    getWebpageJson() {
+        const unidadePath = this.getUnidadePath();
+        const siteURL = getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix);
+        const pagePath = `${siteURL}${this.location.path()}`;
+        const desc = this.activeDescription ? this.activeDescription : '';
+        return {
+            '@type': 'WebPage',
+            '@id': `${pagePath}#webpage`,
+            url: pagePath,
+            inLanguage: 'pt-BR',
+            name: this.getTitle(),
+            isPartOf: { '@id': `${siteURL}${unidadePath}#website` },
+            about: { '@id': `${siteURL}#organization` },
+            description: desc,
+        };
+    }
+    getUnidadePath() {
+        let unidadePath = '';
+        if (this.unidade && this.unidadePath) {
+            unidadePath = this.unidade?.path === '/' ? '' : this.unidadePath?.substring(0, this.unidadePath?.length - 1);
+        }
+        return unidadePath;
+    }
+    /**
+     * Obtém a URL canônica da página.
+     * @returns A URL canônica da página.
+     */
+    getCanonicalHref() {
+        if (!this.canonicalTag) {
+            this.canonicalTag = this.getCanonicalTag();
+        }
+        return this.canonicalTag.href;
+    }
+    /** Cria tag para links canonicals no head */
+    createCanonicalTag() {
+        const tag = this.document.createElement('link');
+        tag.setAttribute('rel', 'canonical');
+        this.document.head.appendChild(tag);
+        tag.setAttribute('href', this.document.URL);
+        this.canonicalTag = tag;
+        return tag;
+    }
+    /** Retorna tag para link canonical existe ou cria se não houver. */
+    getCanonicalTag() {
+        const elements = this.document.head.children;
+        let i;
+        for (i = 0; i < elements.length; i++) {
+            const elem = elements[i];
+            if (elem && elem.tagName === 'LINK' && elem.rel === 'canonical') {
+                return elem;
+            }
+        }
+        return this.createCanonicalTag();
+    }
+    /**
+     * Define link canonical da página
+     * @param url url canonical
+     */
+    setCanonicalHref(url) {
+        if (!this.canonicalTag) {
+            this.canonicalTag = this.getCanonicalTag();
+        }
+        let path = this.document.location.pathname;
+        if (this.libConfig?.siteSufix && path.includes(this.libConfig?.siteSufix)) {
+            path = path.replace(this.libConfig?.siteSufix, '');
+        }
+        if (!path.startsWith('/')) {
+            path = `/${path}`;
+        }
+        const canonicalUrl = url && this.isCustomCanonical(url) ? url : `${getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix)}${path}`;
+        this.canonicalTag.setAttribute('href', canonicalUrl);
+        return this;
+    }
+    /**
+     * Verifica se a URL fornecida é um link canonical personalizado
+     * @param url URL fornecida
+     */
+    isCustomCanonical(url) {
+        const siteurl = getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix);
+        return url.startsWith(siteurl);
+    }
+    /**
+     * Obtém uma url válida na aplicação proveniente de uma URL gerada
+     * pelo plugin Yoast para canonical automático.
+     * Ex.: https://wp.rededorsaoluiz.com.br/brasil/especialidades/cardiologia/
+     * @param urlFromWpApi URL canonica gerada pelo Yoast Plugin.
+     */
+    toLocalCanonical(urlFromWpApi) {
+        const apiUrl = this.libConfig?.wpUrl ?? '';
+        const siteurl = getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix);
+        const unidadeSlug = this.unidadeSlug;
+        let converted = urlFromWpApi.replace(apiUrl, siteurl);
+        if (unidadeSlug !== '/' && converted.includes(`/${unidadeSlug}/`)) {
+            converted = converted.replace(`/${unidadeSlug}/`, `${this.unidadePath}`);
+        }
+        return converted;
+    }
+    getPostContent(post) {
+        const content = post?.acf?.['rdsl_post_content'] ? post?.acf?.rdsl_post_content?.find((content) => content.acf_fc_layout === 'text_html') : null;
+        return content?.content || post.content.rendered || '';
+    }
+    addArticleScript(post, scriptName) {
+        const postContent = this.getPostContent(post);
+        const postHeaderImage = post?.acf?.['rdsl_post_header_img']
+            ? {
+                url: post?.acf?.['rdsl_post_header_img'].url,
+                width: post?.acf?.['rdsl_post_header_img'].width,
+                height: post?.acf?.['rdsl_post_header_img'].height,
+            }
+            : null;
+        const structuredData = {
+            '@context': 'https://schema.org',
+            '@type': 'Article',
+            mainEntityOfPage: `${getSiteUrl(this.libConfig?.siteUrl, this.libConfig?.siteSufix)}${this.location.path()}`,
+            headline: post.title?.rendered,
+            datePublished: post.date_gmt,
+            publisher: {
+                '@type': 'Organization',
+                name: 'Rede D’Or',
+            },
+            description: post.title?.rendered,
+            articleBody: removeHtmlTags(he.decode(postContent)),
+            dateModified: post.modified_gmt,
+            image: {
+                '@type': 'ImageObject',
+                url: postHeaderImage?.url || post.featured_media_path || '',
+                height: postHeaderImage?.height || '',
+                width: postHeaderImage?.width || '',
+            },
+            author: {
+                '@type': 'Organization',
+                name: 'Rede D’Or',
+            },
+            wordcount: postContent.split(' ').length,
+        };
+        const script = this.document.createElement('script');
+        script.type = 'application/ld+json';
+        script.id = scriptName;
+        script.innerHTML = JSON.stringify(structuredData);
+        this.document.head.appendChild(script);
+    }
+    removeArticleScript(scriptName) {
+        const script = this.document.getElementById(scriptName);
+        script?.remove();
+    }
+    setUnidade({ unidade = null, unidadeName = '', unidadePath = '', unidadeSlug = '' }) {
+        this.unidade = unidade;
+        this.unidadeName = unidadeName;
+        this.unidadePath = unidadePath;
+        this.unidadeSlug = unidadeSlug;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SeoService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SeoService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SeoService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class ServerResponseService {
+    constructor() {
+        this.response = inject(RESPONSE, { optional: true });
+    }
+    getHeader(key) {
+        if (this.response) {
+            return this.response.getHeader(key);
+        }
+        return '';
+    }
+    setHeader(key, value) {
+        if (this.response) {
+            this.response.header(key, value);
+        }
+        return this;
+    }
+    appendHeader(key, value, delimiter = ',') {
+        if (this.response) {
+            const current = this.getHeader(key);
+            if (!current) {
+                return this.setHeader(key, value);
+            }
+            const newValue = [...current.split(delimiter), value].filter((el, i, a) => i === a.indexOf(el)).join(delimiter);
+            this.response.header(key, newValue);
+        }
+        return this;
+    }
+    setHeaders(dictionary) {
+        if (this.response) {
+            Object.keys(dictionary).forEach((key) => this.setHeader(key, dictionary[key]));
+        }
+        return this;
+    }
+    setStatus(code, message) {
+        if (this.response) {
+            this.response.statusCode = code;
+            if (message) {
+                this.response.statusMessage = message;
+            }
+        }
+        return this;
+    }
+    setNotFound(message = 'Não encontrado') {
+        if (this.response) {
+            this.response.statusCode = 404;
+            this.response.statusMessage = message;
+        }
+        return this;
+    }
+    setUnauthorized(message = 'Não autorizado') {
+        if (this.response) {
+            this.response.statusCode = 401;
+            this.response.statusMessage = message;
+        }
+        return this;
+    }
+    setError(message = 'Erro interno de servidor') {
+        if (this.response) {
+            this.response.statusCode = 500;
+            this.response.statusMessage = message;
+        }
+        return this;
+    }
+    setRedirect({ statusCode, message, url } = {
+        statusCode: 301,
+        message: 'Redirecionado permanentemente',
+        url: undefined,
+    }) {
+        if (this.response) {
+            this.response.statusCode = statusCode || 301;
+            this.response.statusMessage = message || 'Redirecionado permanentemente';
+            if (url) {
+                this.response.locals['redirectUrl'] = url; // Utilizado no ssr para redirect
+            }
+        }
+        return this;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ServerResponseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ServerResponseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: ServerResponseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+class SsrResponseService {
+    constructor() {
+        this.responseInit = inject(RESPONSE_INIT, { optional: true });
+    }
+    setStatus(code, message) {
+        if (this.responseInit) {
+            this.responseInit.status = code;
+            if (message !== undefined) {
+                this.responseInit.statusText = message;
+            }
+        }
+        return this;
+    }
+    setNotFound(message = 'Não encontrado') {
+        if (this.responseInit) {
+            this.responseInit.status = 404;
+            this.responseInit.statusText = message;
+        }
+        return this;
+    }
+    setError(message = 'Erro interno de servidor') {
+        if (this.responseInit) {
+            this.responseInit.status = 500;
+            this.responseInit.statusText = message;
+        }
+        return this;
+    }
+    setRedirect(params = {
+        statusCode: 301,
+        url: undefined,
+    }) {
+        if (this.responseInit && params.url) {
+            this.responseInit.status = params.statusCode ?? 301;
+            this.responseInit.statusText = params.statusCode === 302 ? 'Found' : 'Moved Permanently';
+            const existingHeaders = this.responseInit.headers ? new Headers(this.responseInit.headers) : new Headers();
+            existingHeaders.set('Location', params.url);
+            this.responseInit.headers = existingHeaders;
+        }
+        return this;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SsrResponseService, deps: [], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SsrResponseService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.18", ngImport: i0, type: SsrResponseService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root',
+                }]
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { AbstractModalComponent, AbstractModalDrawerComponent, EnumDoencaTaxonomy, EnumDoencaTaxonomyCat, ErrorInterceptor, ErrorService, FilterType, GeolocService, GeolocationPermissions, HttpClientService, LIB_CONFIG, LogInterceptor, LogService, MapBoxService, ModalDrawerService, ModalService, PhoneService, PrivacyToolsService, REQUEST, RESPONSE, RdsiteLinkDirective, RdsiteModalComponentStyle, RdsiteModalDrawerComponentStyle, RdsitePhoneModalDirective, SeoService, ServerResponseService, SiteBackendService, SsrResponseService, TransferStateUrlInterceptor, checkSafariAgent, djb2Hash, executeWithRetry, formatPhone, getCircularReplacer, getSiteUrl, removeHtmlTags };
+//# sourceMappingURL=rededor-site-front-end-lib-core.mjs.map